Fresh Devoured
DEVOURED
GPT-6 Cyber

GPT-6 Cyber

AI OpenAI
OpenAI launched GPT-6 Cyber, a specialized model for identifying exploitable software vulnerabilities within predefined security research constraints.
What: OpenAI released GPT-6 Cyber, an AI model designed to assist researchers in finding and validating security vulnerabilities.
Why it matters: This indicates a shift toward deploying models with specific, scoped operational boundaries rather than general-purpose agents for sensitive offensive tasks.
Original article

OpenAI introduced GPT-6 Cyber, a cybersecurity model designed to identify and validate exploitable vulnerabilities while staying within researcher-defined boundaries.

DEVOURED
Introducing Inkling 2 Small

Introducing Inkling 2 Small

AI Thinking Machines
Thinking Machines released Inkling 2 Small, a 594B-parameter Mixture-of-Experts model that excels at agentic coding and visual reasoning.
What: Inkling 2 Small is a Mixture-of-Experts model with 17B active parameters, offering visual-feedback-based iteration for tasks like website generation and 3D design. It achieved high performance on agentic coding benchmarks and includes vision-in-the-loop capabilities for complex task execution.
Why it matters: The focus on 'agentic' models that can write, execute, and fix their own code through environmental feedback marks a shift from passive text generation to autonomous workspace execution.
Takeaway: Test Inkling 2 Small via the Tinker Playground to evaluate its agentic capabilities for your own development workflows.
Deep dive
  • Features a 292M-parameter vision encoder and supports image inputs.
  • Uses RL-based training on hundreds of thousands of long-horizon coding tasks.
  • Implements an asynchronous monitor to inspect tool calls and prevent model misbehavior during training.
  • Achieves high performance on benchmarks like DesignArena and SWEBench Pro.
  • Utilizes NVFP4, a 4-bit floating-point format native to NVIDIA Blackwell GPUs, during training.
  • Employs sticky routing and DRAM KV-cache offloading to maintain high prefix cache hit rates for long-context tasks.
Decoder
  • Mixture-of-Experts (MoE): A model architecture where only a subset of parameters ('experts') is activated for each input, improving inference speed and efficiency.
  • Agentic: A model characteristic where the system can act autonomously, use tools, and iterate on solutions through a feedback loop.
  • KV-Cache: A memory buffer that stores key-value pairs of previously generated tokens to speed up inference by avoiding redundant computation.
Original article

Full article content is not available for inline reading.

Read the original article →

DEVOURED
Independent Assessment of AI R&D Acceleration at Anthropic in October 2026

Independent Assessment of AI R&D Acceleration at Anthropic in October 2026

AI METR
METR's independent assessment found that Anthropic’s AI R&D capabilities have accelerated by roughly 2x since late 2025.
What: Researchers at METR conducted a 11-week high-access evaluation at Anthropic, concluding that AI assistance in R&D is likely the primary driver of a doubling in capability improvement rates. The report highlights that compute scaling is not the cause of this acceleration.
Why it matters: This quantifies the 'AI-building-AI' feedback loop, validating concerns that AI adoption in research can lead to compounding acceleration in capability development.
Deep dive
  • Anthropic models are growing on benchmarks at 1.9x the pre-October 2025 rate.
  • The speedup is primarily attributed to AI-assisted coding and experimentation rather than fully autonomous R&D.
  • No immediate bottlenecks in hardware or data were identified that would halt this trajectory in the next year.
  • Anthropic exercised broad redaction rights over findings that could 'accelerate other AI developers'.
  • The assessment relied on the Epoch Capabilities Index (AECI) to measure capability growth.
Decoder
  • AECI (Epoch Capabilities Index): A composite benchmark metric used to track the progress of AI models on various tasks over time.
  • Capability acceleration: A measurement of how much faster a model's performance improves compared to historical trends.
Original article

Full article content is not available for inline reading.

Read the original article →

DEVOURED
You can now build live apps in Cursor and share them with a link

You can now build live apps in Cursor and share them with a link

AI Cursor
Cursor now allows users to deploy functional, database-backed applications directly from a prompt with a single shareable link.
What: The Cursor AI editor has integrated a feature that handles the full stack creation process—building the app, setting up the database, performing automated security checks, and deployment—based on natural language descriptions.
Why it matters: This signals a transition for AI coding assistants from mere text generation to full-lifecycle infrastructure management, attempting to solve the 'localhost gap' where prototypes rarely reach production.
Deep dive
  • Automates database provisioning for generated applications
  • Integrates deterministic and agentic security verification prior to deployment
  • Enables instant production deployment without manual configuration
  • Removes the infrastructure overhead usually required to share a running app
Decoder
  • Deterministic security: Security checks that follow pre-defined, logic-based rules to find vulnerabilities.
  • Agentic security: Security checks performed by AI agents that use reasoning and tools to identify complex or context-dependent flaws.
Original article

You can now build live apps in Cursor and share them with a link. Agents have made it easier to write code, but most apps never make it off localhost. Describe the tool you want - Cursor will build it, set up a database, run deterministic and agentic security checks, and deploy.

DEVOURED
Meet *sshole, the vulnerability that lets hackers SSH into Linux devices

Meet *sshole, the vulnerability that lets hackers SSH into Linux devices

Tech Ars Technica
A critical vulnerability named '*sshole' allows attackers to bypass SSH authentication on Linux systems using specific musl and OpenSSH configurations.
What: The *sshole flaw allows unauthorized SSH access to systems running Alpine Linux (or other distros using musl without PAM) if the target account is passwordless and hashes exist in /etc/shadow; it requires inputting a string over 256 characters.
Why it matters: This reveals the danger of configuration-dependent security bugs in common base layers like Alpine Linux, which is heavily relied upon in containerized microservices and embedded devices.
Takeaway: Check if your production Linux systems use musl combined with OpenSSH without PAM; if so, apply the latest patches immediately.
Deep dive
  • Vulnerability: Exploits OpenSSH's interaction with the musl C library.
  • Requirements: Must use musl, OpenSSH without PAM, and have a user account with a non-empty hash in /etc/shadow despite having a passwordless setting ('*').
  • Impact: Full authentication bypass without a password.
  • Root cause: Disputed; OpenSSH developers cite caller error (musl), while musl maintainers consider it an incorrect implementation by the caller.
  • Detection: Affected systems likely include Alpine Linux, OpenWRT (if OpenSSH is installed), and potentially Yocto/Buildroot configurations.
Decoder
  • musl: A lightweight, minimalist implementation of the C standard library designed for use in embedded systems and Linux distributions like Alpine.
  • PAM (Pluggable Authentication Modules): A mechanism for integrating multiple low-level authentication schemes into a single API.
  • /etc/shadow: The system file on Linux that stores encrypted password hashes, restricted to root access.
Original article

Devices running some configurations of Alpine Linux, and possibly other distributions, are affected by a decade-old vulnerability that allows attackers to log into devices with no password.

The vulnerability exists in the interaction between OpenSSH, the code library implementing SSH connections, and musl, a lightweight alternative to the libc library that, unlike most other Linux distributions, is used in Alpine. Further, OpenSSH using musl (pronounced muscle) must not use PAM (pluggable authentication modules), a framework that handles user authentication and account-access checks. Alpine is a lightweight, widely used Linux distribution. Other platforms may be affected if they use the same configurations.

One connection, works every time, needs no retries

There are two other conditions necessary for successful exploitation. First, a system must have at least one user account that’s accessible using a password that is hashed using the SHA256 or SHA512 functions. Second, the target system account must be configured to be passwordless, by way of specifying a “*” in the password field in /etc/shadow, the Linux file where password hashes are stored. Passwordless accounts are commonly used for accounts that use certificate-based authentication. This setting is common for certain types of accounts.

When all the conditions are met, the consequences are high.

“An attacker who can reach your SSH port can log in without knowing any password,” Alpine maintainers said Thursday. “It takes one connection, works every time, and needs no retries.”

When logging into a passwordless account, the attacker can gain access by inputting more than 256 characters in the password field.

Security firm Checkpoint said that the use of the SHA256 or SHA512 functions “matters because sshd borrows that account’s salt. Without it, the attack fails.” Company researchers said their testing also showed that the account must be active, not just hold a hash. Checkpoint further reported that root accounts are safe under the default PermitRootLogin prohibit password setting, though reachable accounts with doas or sudo rights can still become root.

Despite the prerequisites, *sshole—the vulnerability name given by the person who discovered it—likely threatens large numbers of systems. The Docker Hub base image for Alpine has more than 1 billion downloads. Alpine has long been popular in routers, smart TVs, industrial controllers, and other types of embedded devices, many of which can’t be easily updated, if at all. More recently, Alpine has been adopted for use in desktops and servers. Alpine is also used in many container images.

According to security firm Detectify, Shodan lists around 22 million systems with SSH open on port 22. Only a fraction meet the conditions necessary for exploitation, but given the ease and speed of testing each one, locating vulnerable devices won’t require much effort or time.

It’s not entirely clear where the vulnerability resides. OpenSSH, which issued an update Thursday, said: “We consider the root cause of this bug to be outside sshd, but it is exploitable via sshd and can be avoided there.” Musl developer Rich Felker, meanwhile, wrote: “It is my position that this is not a bug in musl just an erroneous use by the caller.” Felker went on to say that musl developers have wanted to make changes to the mechanism “for a while now” and planned to do so in an upcoming release. Alpine has also issued an update.

It’s not yet known what other packages may be vulnerable. The person who discovered *sshole said OpenWRT is affected, but by default, that OS uses the Dropbear package, not OpenSSH, for SSH connections (though maintainers provide instructions for installing the latter). The discoverer also names the packages buildroot and yocto as being affected, but that isn’t yet confirmed.

Despite the uncertainty, anyone using a Linux system that uses both musl and OpenSSH should take time to immediately investigate if they’re affected. A good starting point is here. Both Alpine and OpenSSH patches should be installed on all affected systems. There is no known CVE designation for the vulnerability.

DEVOURED
The Exploit Was the Bottleneck

The Exploit Was the Bottleneck

Tech A16z
AI agents have collapsed the time between vulnerability disclosure and weaponized exploit from weeks to hours, making manual patching obsolete for many.
What: Asaf Ezra and Stephenie Zhang of a16z report that AI agents can now chain zero-day vulnerabilities in under an hour, evidenced by incidents such as a September 2026 help-desk compromise and the exploitation of critical PHP bugs. Despite AI’s efficacy, the authors argue the internet will not collapse because critical infrastructure relies on physical protection, not just software.
Why it matters: The economic bottleneck in offensive security—the time and expertise required to build a working exploit—has been removed, shifting the threat landscape from sophisticated state actors to anyone with access to cheap, open-weight models.
Deep dive
  • Vulnerability Window: The time between public disclosure of a bug and its exploitation is now frequently negative, with attacks occurring before patches are available.
  • Automation: AI agents automate the entire lifecycle of an attack, including scanning, lab setup, exploit creation, and lateral network movement.
  • Infrastructure Risk: Small, internet-exposed industrial systems (water, electricity, refrigeration) are the most vulnerable as they cannot be patched or isolated as quickly as large cloud platforms.
  • Metric Changes: Developers should monitor 'exploited-vulnerability counts' and 'time-to-patch' to gauge if their security posture is failing against automated threats.
  • Platform Security: The authors contend that the safest approach is to shelter applications behind managed cloud platforms that can apply edge protections at machine speed.
Decoder
  • Zero-day: A software vulnerability that is unknown to the vendor and therefore has no existing patch.
  • Open-weight models: AI models whose internal parameters (weights) are publicly available for download and execution on private hardware, unlike closed-API models.
  • Wiper: Malware designed specifically to destroy data rather than hold it for ransom.
Original article

Full article content is not available for inline reading.

Read the original article →

DEVOURED
Alpine Linux Security Advisory: OpenSSH-server password authentication bypass

Alpine Linux Security Advisory: OpenSSH-server password authentication bypass

DevOps Alpinelinux.org
A vulnerability in Alpine Linux's openssh-server allows remote attackers to bypass password authentication if the system contains at least one user with a password hash.
What: Alpine Linux packages for openssh-server (versions 3.16 through 3.24) contain a flaw where musl's crypt() function returns an error indicator that matches the stored password field for key-only accounts. Affected systems can be compromised if an attacker knows an account name with no password and the machine contains at least one other account with a standard hash.
Why it matters: This incident highlights how minimal Linux distributions that rely on alternative C libraries like musl may introduce non-standard security behaviors when interacting with common software like OpenSSH.
Takeaway: Update your Alpine Linux packages using apk upgrade -U -a and restart the sshd service immediately, or set PasswordAuthentication no in /etc/ssh/sshd_config.
Decoder
  • musl libc: A lightweight standard C library designed for Linux kernel-based systems, used by Alpine Linux as an alternative to the more common glibc.
  • sshd: The OpenSSH daemon that manages remote connections via the Secure Shell protocol.
  • crypt(): A C library function used to hash passwords and verify them against stored hashes.
Original article

Security advisory: openssh-server password authentication bypass

If you run sshd on Alpine Linux, update openssh now and restart sshd. Upgrading the package alone does not replace the running daemon.

If you cannot update yet, at least disable password logins: set PasswordAuthentication no in your sshd configuration and restart sshd. Either one closes the hole.

What is the problem?

An attacker who can reach your SSH port can log in without knowing any password. It takes one connection, works every time, and needs no retries.

The attacker needs the name of an account whose password field is * (an account with no password set, which is normal for key-only accounts), and needs the machine to have at least one other account with a $5$ or $6$ password hash. The attacker then sends a very long password (257 to 1024 bytes). One user with a password is enough: it makes every account without one reachable.

Who is affected?

You are affected if all of the following are true:

  • You run the Alpine openssh-server package, which is built without PAM, or you run openssh-server-pam with UsePAM no. (openssh-server-pam with UsePAM yes is not affected.)
  • PasswordAuthentication is yes (the OpenSSH default, unless you changed it).
  • The machine has an account whose password field is *. This includes:
    • root, which ships as root:* in the base image since about Alpine 3.16. OpenSSH’s default PermitRootLogin prohibit-password protects root, so root is only reachable if PermitRootLogin yes is set. That does not help if another account that can log in is able to become root, for example through doas.
    • Any key-only user created with adduser without a password, or with usermod -p '*'.
    • Users coming from a directory service through musl-nscd (nslcd, winbind, sssd), since they have no shadow entry.
    • The alpine user in the official tiny-cloud images.
  • At least one local account has a $5$ or $6$ password hash.

Affected releases: every Alpine release we checked, 3.21 through 3.24 and edge, and the older releases that no longer receive regular updates (3.16 to 3.20).

Who is not affected?

  • Docker and other container users that do not run sshd in the container.
  • Systems with PasswordAuthentication no.
  • Systems using openssh-server-pam with UsePAM yes (with UsePAM no you are affected).
  • Locked accounts: those with ! as the password field in /etc/shadow (a line starting user:!:). They cannot log in with a password or a key.
  • Systems where no account has a $-style password hash.
  • Cloud images configured through cloud-init, which writes PasswordAuthentication no.

How can I fix it?

1. Update

apk upgrade -U -a

Alpine 3.21.10, 3.22.8, 3.23.8 and 3.24.4 contain the fixed package. The fixed package versions are:

Branch Fixed openssh version
edge 10.6_p2-r0
3.24 10.3_p1-r2
3.23 10.2_p1-r1
3.22 10.0_p1-r11
3.21 9.9_p2-r1
3.20 9.7_p1-r6
3.19 9.6_p1-r3
3.18 9.3_p2-r4
3.17 9.1_p1-r7
3.16 9.0_p1-r6

Restart sshd after upgrading (rc-service sshd restart). Upgrading the package does not restart a running sshd, so you must do it after.

2. If you cannot update: disable password authentication

Before you start, make sure your SSH key login works, and keep your current session open until you have tested a new login.

mkdir -p /etc/ssh/sshd_config.d
echo 'PasswordAuthentication no' > /etc/ssh/sshd_config.d/00-no-passwords.conf
sed -i.bak -e '1i PasswordAuthentication no' \
  -e 's/^\(\s*PasswordAuthentication[^y#]*\)yes/\1no/i' \
  /etc/ssh/sshd_config
sshd -t && rc-service sshd restart
sshd -T | grep -i passwordauthentication

The last command should print passwordauthentication no. To undo, delete /etc/ssh/sshd_config.d/00-no-passwords.conf and copy /etc/ssh/sshd_config.bak back over /etc/ssh/sshd_config.

Cloud images (tiny-cloud)

The official tiny-cloud images from 3.18.11 through 3.24.3 ship an alpine user with a * password field and passwordless doas. They are safe on first boot. They become exploitable as soon as any $6$ hash exists on the machine, for example when an admin sets a console password, or user-data adds a user with hashed_passwd. An attacker then gets a shell as alpine and can use doas to become root.

Images built from 3.21.10, 3.22.8, 3.23.8, 3.24.4 and later include the fixed package. Images from earlier point releases do not, so on every running instance, update openssh or disable password authentication.

Releases that are no longer supported (3.21 and older)

These releases have the same bug. 3.21 reached its end of support on 2026-11-01, but we have published fixed packages for each release all the way back to 3.16.

How do I know if I was attacked?

Look in /var/log/messages for sshd lines reading Accepted password for an account that has no password (alpine, root, or any key-only user). Review doas use and recently created users, files and authorized keys on exposed machines. If you cannot rule out a login, treat the machine as compromised.

How could this happen?

When sshd is built without PAM, it checks a password by hashing the attempt with crypt() and comparing the result to the stored password field. For an account whose stored field is too short to contain a salt, sshd borrows the salt of another account.

musl’s crypt() returns the string * as an error indicator when the key is over 256 bytes long. * is also exactly what the stored field contains for every account with no password, so the “hash” matches and the login succeeds.

DEVOURED
When the Kubernetes API went silent: A three-layer networking mystery

When the Kubernetes API went silent: A three-layer networking mystery

DevOps Google Cloud
Google engineers traced a GKE API timeout issue to a rare 'perfect storm' of packet reordering, Linux kernel bugs, and Envoy half-close behavior.
What: The investigation resolved intermittent API timeouts across GKE clusters by identifying three simultaneous issues: reordered packets via the Private Service Connect fabric, Envoy keeping sockets open in a 'half-closed' state, and a bug in the Linux 6.1 kernel that prevented the closure of these connections.
Why it matters: This case illustrates the extreme complexity of modern cloud networking, where a fix in one security layer (USPS) accidentally exposed an underlying latent bug in the Linux kernel TCP state machine.
Deep dive
  • The Networking Path: Pods connect to the Kubernetes API through a virtual endpoint managed by Private Service Connect, which NATs traffic and injects proxy protocol headers.
  • The Bug Cascade: Packet reordering at the virtual NIC caused clients' FIN packets to arrive out of order.
  • Socket Persistence: Envoy's graceful 'half-close' (SHUT_WR) prevented the kernel from considering the sockets 'orphaned,' meaning tcp_fin_timeout never triggered.
  • The Kernel Fix: Linux kernel commit 795a7dfbc3d9 was authored by Eric Dumazet to properly handle 'old but acceptable' ACKs in the closing sequence, fixing the silent FIN discard issue.
  • Lesson: When troubleshooting complex network timeouts, simultaneous packet captures at multiple points (NIC, container, etc.) are essential to detect reordering.
Decoder
  • FIN_WAIT_2: A TCP state where the local side has sent a FIN and received an ACK, but is waiting for the remote side to send its own FIN.
  • 5-tuple: A set of five values (source IP, source port, destination IP, destination port, and protocol) that uniquely identifies a TCP connection.
  • RFC 5961: A set of security standards for TCP that define how stacks should respond to unexpected packets (like challenge ACKs) to prevent data injection attacks.
Original article

When the Kubernetes API went silent: A three-layer networking mystery

Every support engineer has a case that stays with them. The one that comes up at team lunches. The one where, even after it's resolved, you find yourself staring at a packet capture at midnight just to make sure you really understand what happened. This is that case.

It started in January 2026 with a support ticket that read deceptively simply: pods are intermittently failing to reach the Kubernetes API server. The error was a familiar-looking timeout. The customer had already ruled out their own operators. What none of us knew yet was that we were looking at three separate bugs — in three different layers of the stack — all conspiring to produce the same symptom at the same time.

By the time it was over, around 800 developers had been blocked from deploying to production for weeks on end, and GKE clusters across europe-west had ground to a halt. In a race to fix the problem, we involved engineers across Google Kubernetes Engine (GKE), Private Service Connect, networking, hostnet, kernel, and the Linux upstream community, who together tracked down not one but three distinct root causes. And the final fix landed not as a config change or a feature flag, but as a patch to the Linux kernel itself.

This is the story of how we got there.

Part one: The alarm bell that wouldn't stop

The customer ran a large multi-cluster GKE environment in Google Cloud's europe-west region. Their clusters used Private Service Connect — Google Cloud's mechanism for exposing the GKE control plane privately — and had a rich ecosystem of system-level workloads: Twistlock security scanners, External Secrets Operator for secrets management, Cilium for network policy, as well as several internal Kubernetes operators.

The first errors appeared in one of its user acceptance testing (UAT) clusters in europe-west, and a few days later in a second cluster in the same region. They looked like this:

TimeoutError: Connect call failed ('1.2.3.4', 443) dial tcp 1.2.3.4:443: i/o timeout

Initially the errors were intermittent — spikes in the logs, not a hard outage. The customer suspected their own code. Their team had recently deployed a custom operator built with the kopf framework, and it was the first thing they looked at. But the logs showed the errors had started eight days before the operator was ever deployed. When they shut it down completely, the timeouts kept coming.

Part two: Tracing the ghost in the wire

To understand what the packet captures revealed, you first need to understand the architecture that a GKE pod traverses when it makes an API call. In a Private Service Connect-based GKE cluster, the path is deceptively long for something that looks like a local connection.

The key component here is Private Service Connect. When a pod dials 1.2.3.4:443, it is not actually going directly to the control plane; that IP is a virtual endpoint. The connection is intercepted by Google's networking fabric, NAT'd through a Private Service Connect endpoint, passed through an internal passthrough Network Load Balancer, and ultimately delivered to the KCP VM, where Envoy acts as a local proxy in front of the actual kube-apiserver process.

Private Service Connect adds a proxy protocol header to each new connection, so the kube-apiserver can see the real client IP. This will turn out to be important later.

What the packets revealed

When we captured simultaneously at the KCP VM's NIC and from inside the kube-apiserver container, we saw something striking. SYN packets from the pods were arriving at the KCP VM's NIC. But instead of receiving a SYN-ACK in response — the expected second step of a TCP handshake — the client was getting back an out-of-place ACK. Not an RST. Not silence. An ACK that logically belonged to a different, earlier connection.

The "Invalid ACK" spike

While one thread of the investigation was analyzing packet captures, another team was digging into internal metrics for the Private Service Connect infrastructure — specifically the user space packet switch (USPS), Google's software switching layer that handles NAT and proxy protocol header injection for Private Service Connect connections. They found that a counter called "Proxy protocol drop: invalid ACK packet" had spiked sharply upward in February 2026, coinciding with a USPS version rollout.

Challenge ACKs: The RFC 5961 mechanism

RFC 5961 defines a security mechanism called the challenge ACK. When a server receives a SYN that matches an existing or recently-closed connection's remembered state, it sends a challenge ACK — an acknowledgment carrying the last known sequence number — to verify if the new client is legitimate. If the client doesn't recognize the sequence, it sends a RST to clear the state, allowing the server to accept the next SYN normally.

The culprit: A well-intentioned fix

The change in USPS had been designed to drop packets classified as "invalid ACKs" during the connection handshake phase. Unfortunately, challenge ACKs arrive from the server before the new handshake has completed; the new USPS logic identified these as invalid and dropped them silently. Because Private Service Connect uses NAT to share a single public endpoint, the high rate of port collisions made these challenge ACKs a frequent necessity for clearing stale states, which were now being blocked.

Part three: Three bugs, one crime scene

The mitigation (rolling back the USPS change) bought us time, but it left a question: Why did the KCP VM keep connections in FIN_WAIT_2 for so long? The answer involved three distinct failure modes.

Bug #1: Packet reordering at the PIGv

Due to how Private Service Connect's miss-thread processing works, packets occasionally appeared at the KCP VM's virtual NIC (PIGv) in a different order than they arrived at the host NIC. This resulted in a client's FIN arriving after the server had already sent its own FIN, causing the server's kernel to ignore the client's packet.

Bug #2: Envoy's half-close and the frozen timer

Envoy, the proxy in front of the kube-apiserver, was performing a half-close (SHUT_WR). Because the socket was not yet "orphaned," the Linux tcp_fin_timeout parameter never fired. The socket sat in FIN_WAIT_2 indefinitely, waiting for a client FIN it would never be able to process correctly due to the reordering.

Bug #3: The Linux kernel's silent failure

Finally, we discovered a bug in the Linux kernel 6.1 implementation of tcp_ack(). When an ACK was received that was "old but acceptable" under RFC 5961, the function returned zero, causing the caller to silently discard the incoming FIN instead of moving the connection to TIME_WAIT. This prevented the kernel from cleaning up the connection naturally.

The resolution: A three-pronged fix

  • Immediate mitigation: Rollback of the USPS change in February 2026 restored the pass-through of challenge ACKs.
  • Correctness fix: A replacement change to handle the challenge ACK scenario properly in the Private Service Connect proxy protocol layer.
  • Root cause fix: An upstream Linux kernel patch (authored by Eric Dumazet, committed as 795a7dfbc3d9) was backported to the 6.1 and 6.6 LTS branches to correctly handle old-but-acceptable ACKs during connection close.

Most networking cases resolve at one layer. This one was different because the symptom was the same whether you were looking at the Private Service Connect layer, the kernel's TCP state machine, or Envoy's connection management. What finally cracked it was the discipline of simultaneous packet capture at multiple points in the path and the collaboration of engineers across many different specialties.

DEVOURED
Auto Ontology (GitHub Repo)

Auto Ontology (GitHub Repo)

DevOps GitHub
NVIDIA's Auto Ontology framework enables AI agents to query enterprise data with semantic precision by building a knowledge graph over relational metadata.
What: The open-source framework, written in Python with FastAPI, automatically generates an ontology from database schemas, maps relationships, and provides an MCP-compatible interface for NL-to-SQL tasks, backed by NVIDIA NIM models.
Why it matters: This indicates a shift toward 'grounded' agents where deterministic semantic layers—rather than just vector search—are used to minimize hallucinations in enterprise data retrieval.
Takeaway: Developers can start by cloning the repo and pointing it at a database to evaluate if it correctly resolves business terminology for their existing schemas.
Deep dive
  • Automatically discovers schemas and maps business terms across databases.
  • Implements a semantic catalog using Postgres and pgvector.
  • Provides tools for users to certify definitions and SQL expressions.
  • Exposes functionality via MCP for integration with Claude Desktop or Cursor.
  • Leverages NVIDIA NIM endpoints (Nemotron models) for reasoning and embedding tasks.
  • Enforces authentication via Better Auth and provides a web UI for auditing SQL generation.
Decoder
  • Ontology: A formal representation of knowledge as a set of concepts within a domain and the relationships between those concepts.
  • MCP (Model Context Protocol): An open standard that allows AI assistants to connect to data sources, tools, and systems in a standardized way.
  • NIM (NVIDIA Inference Microservice): A set of optimized containers and APIs for running AI models across various hardware.
Original article

Auto Ontology

Agents can retrieve documents and query databases, but reliability gates agentic analytics: a revenue metric answered faster is worth nothing if the number is wrong. Agents need a context layer that tells them where data lives, what it means, whether to use it, how to use it, where it came from, and what is similar. NVIDIA Auto Ontology is an open library that builds that layer from enterprise metadata, reconciles definitions across systems, and exposes it to any agent harness through MCP, CLI, and API. It complements the semantic models customers already own.

It enables developers to:

  • Discover: generate enterprise ontologies from metadata; connect existing ontologies and semantic models; build AI-ready knowledge graphs.
  • Ground: give agents trusted business meaning for metrics, entities, and relationships; reconcile inconsistent definitions across systems.
  • Validate: check generated queries against certified definitions and lineage; return provenance with every answer.
  • Expose: serve context to any agent harness through MCP, CLI, and API. Learn: fold certified corrections and usage back into the ontology, so shared context improves with every question.

Benchmarks

To run a text-to-SQL benchmark such as BIRD, refer to the ontology SQL evaluation repository.

Licensing & contributions. Auto Ontology is distributed under the Apache License 2.0. Third-party open-source components bundled, linked, or otherwise used by this project are listed in THIRD_PARTY_NOTICES.md. This project is currently not accepting external contributions.

Key Features

  • Natural-language querying of structured data — questions are translated to SQL and executed against connected databases, powered by NVIDIA NIM.
  • Semantic catalog / ontology layer over relational sources, stored in Postgres alongside the catalog it describes.
  • Authentication & RBAC —using Better Auth.
  • Web UI for chat, analysis, data catalog, analytics, and settings.
  • Flexible deployment — Helm chart for Kubernetes or Docker Compose for a local stack.

Software Components

Component Technology Role Default port
Frontend Next.js 16 (React 19, TypeScript, Tailwind CSS 4), Better Auth, Prisma Web UI, authentication, API gateway 3000
Backend FastAPI (Python 3.12+), LangChain Chat / NL-to-SQL, catalog, datasource APIs 3001
Ingestion worker FastAPI (Python 3.12+) Ingests tabular data and writes embeddings 3002
Postgres + pgvector Relational Database App metadata, the catalog and ontology, vector store 5432
HashiCorp Vault Optional Secure storage of connection credentials —

NVIDIA NIM

Auto Ontology uses NVIDIA NIM endpoints for inference — either the hosted NVIDIA API catalog or self-hosted NIMs.

Model triplets

Each model role is configured by a triplet of environment variables — <PREFIX>_ENDPOINT (URL), <PREFIX>_API_KEY, and <PREFIX>_MODEL:

Prefix Role
DEFAULT_MODELS Shared default; every field below falls back to it.
REASONING Main chat / NL-to-SQL model.
NON_REASONING Lighter model used for entity extraction.
EMBED Text-embedding model (must match between ingest and query).
RERANK Reranker used by the retrieval flow.

Quickstart

  1. Clone the repository and create .env:

    git clone https://github.com/NVIDIA/auto-ontology.git && cd auto-ontology
    cp .env.example .env
  2. Start Postgres and load the sample database.

  3. Build and start the rest of the stack:

    docker compose up -d --build
  4. Open http://localhost:3000 and sign in.

How it works

Auto-Ontology works in three stages: it generates an ontology, people certify it, and the agent answers questions from it.

The ontology holds three kinds of definition:

  • Terms. Business concepts such as Customer or Invoice Line, each with a description and synonyms, mapped to the columns that hold them.
  • SQL attributes. Reviewed SQL expressions under a term, such as a margin or a rolling total. The agent reuses them, so answers compute each measure the same way.
  • Relationships. How tables join, including bridge tables, inferred from keys and from the data.

Integrate with us

To integrate an agent platform, application, or storage provider with Auto-Ontology, open an integration request.

License

Auto-Ontology is licensed under the Apache License, Version 2.0. SPDX identifier: Apache-2.0.

Notice and Disclaimer

NOTICE AND DISCLAIMER: This software automatically retrieves, accesses or interacts with external materials. Those retrieved materials are not distributed with this software and are governed solely by separate terms, conditions and licenses. Use this software and the retrieved materials at your own risk.

DEVOURED
Announcing the OpenTelemetry JavaScript SDK 3.0

Announcing the OpenTelemetry JavaScript SDK 3.0

DevOps Opentelemetry
OpenTelemetry JavaScript SDK 3.0 has officially dropped support for older Node.js versions and moved to an ESM-only distribution model.
What: The major release, v3.0.0, includes stabilization of the Logs signal, improved attribute support, and the removal of deprecated packages like jaeger-exporter.
Why it matters: The project is accelerating its release cadence to track major Node.js lifecycle changes and improve compatibility with modern bundlers and ESM-native tooling.
Takeaway: Plan your migration to Node.js >=22.15.0 before updating, and consult the OTel JS migration guide for breaking API changes.
Deep dive
  • Minimum Node.js version is now 22.15.0.
  • Logs signal is officially stable and integrated into @opentelemetry/api.
  • Added support for complex attributes in logs and spans (OTEP 4485).
  • Consolidated tracing packages into @opentelemetry/sdk-trace.
  • Removed legacy shims and exporters (Jaeger, OpenCensus, OpenTracing).
Decoder
  • ESM (ECMAScript Modules): The official standard format for JavaScript modules, replacing the older CommonJS require() syntax.
Original article

Announcing the OpenTelemetry JavaScript SDK 3.0

OpenTelemetry JavaScript has released SDK 3.0 (stable v3.0.0 packages and experimental v0.300.0 packages) and API 1.10.0.

For a detailed description of breaking changes, see the OpenTelemetry JS SDK 3.x migration guide.

What is JS SDK 3.x?

JS SDK 3.x encompasses new releases of the @opentelemetry/* JavaScript packages published from the opentelemetry-js repository, except the API and semantic-conventions packages. The package versions for this new major will be >=3.0.0 for the stable and >=0.300.0 for the unstable packages. Details on the full list of packages can be found in the migration guide.

In addition, all the packages from the opentelemetry-js-contrib repository have been upgraded to JS SDK 3.x and released.

Per OpenTelemetry guidelines, the 2.x versions of stable SDK packages will be supported for one year from the 3.0.0 release.

What has changed?

  • The minimum supported Node.js has been raised to >=22.15.0. This means that support for Node.js 18 and 20 has been dropped.
  • All packages now ship proper ES Module (ESM) and CommonJS exports. The result should be much friendlier to ESM and bundler users.
  • Support for complex attributes, per OTEP 4485, has been added to some parts of the API (e.g. span attributes, log record attributes). Some parts of the API only support simple attributes (e.g. resource attributes, metric attributes). See the explainer in the migration guide.
  • The @opentelemetry/api-logs package has been folded into @opentelemetry/api, as the Logs signal has been stabilized! With Logs stabilized, all three OpenTelemetry signals (Traces, Metrics, and Logs) are now stable in JavaScript. There will be a separate blog post on this stabilization.
  • Multiple Tracing SDK packages have been consolidated into the @opentelemetry/sdk-trace package, eliminating some confusing APIs and bringing consistency with the SDKs for the other signals.
  • Many deprecated packages have been removed, including @opentelemetry/propagator-jaeger, @opentelemetry/exporter-jaeger, @opentelemetry/shim-opentracing, and @opentelemetry/shim-opencensus. See the migration guide for the full list.
  • The public interface has changed. Several public types and class names have been renamed or moved.

The API package (@opentelemetry/api) does not have breaking changes. As well, users using the @opentelemetry/auto-instrumentations-node package as described at zero-code instrumentation do not need to change.

For more details and notes on migrating to 3.x / 0.300.x, see the migration guide.

Why was this done?

Starting with the SDK 2.0 release in March 2025, the OTel JS SIG has had a goal of a new SDK major release roughly every year. This cadence allows us to stay current with new major Node.js releases and more recent JavaScript ecosystem and tooling improvements.

For 3.0 specifically:

  • Node.js 20 reached end-of-life in April 2026.
  • Shipping proper ESM exports required changes to package entry points.
  • Removing deprecated and unmaintained packages lets the SIG focus on current features.
  • Logs stabilization and complex attribute support required API and SDK changes.

How can I get involved?

There are several ways to help shape SDK 3.x and beyond:

Acknowledgments

Shipping a major release is a lot of coordinated work, and SDK 3.0 would not exist without the many people who put time into it. Thank you to the OpenTelemetry JavaScript SIG for the design discussions, the migration PRs, the long reviews, and the many careful decisions about what to break and what to keep. Thanks also to the broader OpenTelemetry community and to everyone who contributed to this release.

DEVOURED
Gemini Omni 1.2 Flash

Gemini Omni 1.2 Flash

AI Google
Google launched Gemini Omni 1.2 Flash, featuring 15-second native video generation and a 30% price reduction.
What: Gemini Omni 1.2 Flash introduces 15-second clips, improved reference adherence for characters and objects, and multi-turn conversational editing for refining scenes without re-generating from scratch.
Why it matters: The focus on reference adherence and sequential editing signals that generative video is moving toward becoming a predictable production tool for professional workflows.
Takeaway: Access Gemini Omni 1.2 Flash via the Gemini API or Google AI Studio to experiment with multi-turn clip refinement.
Decoder
  • Reference adherence: The capability of a model to maintain visual fidelity to provided input imagery or character sheets across video generations.
Original article

Gemini Omni 1.2 Flash: Fast and cost-effective with longer clips

Gemini Omni 1.2 Flash brings 15-second clips, stronger consistency, and faster, more cost-effective generation.

We’re rolling out Gemini Omni 1.2 Flash, which offers native 15-second video creation, improved reference adherence, and multi-turn conversational editing. This update lowers costs by 30% and provides better consistency for your professional projects. You can start using these capabilities today across the Gemini API, Google Vids, and Gemini for business to produce high-quality video content at scale.

Today, we’re rolling out Gemini Omni 1.2 Flash, and making it generally available across the Gemini API and Gemini for business. Gemini Omni 1.2 Flash introduces native 15-second video creation, multi-turn conversational editing capabilities, and enhanced reference following. We have dropped the price 30% from Gemini Omni 1.1 making it available at $0.07 per second for 720p video.

Here’s an overview of what’s new:

Fast and cost-effective at scale

Beyond the lower price, the workflow keeps costs down: you can draft fast at 360p or 720p, fix a detail with a follow-up edit instead of re-generating the entire clip, and then upscale your best creations to 1080p or 4K.

Longer clips up to 15 seconds

You can now generate and edit videos natively up to 15 seconds long, up from 10 seconds with Omni 1.1. You can also specify duration in one-second increments from 3 to 15 seconds, giving you room to tell complete stories, create product explainers, or produce full social ad spots in a single generation.

Better reference adherence

You can guide generation combining character, product, or style images, short motion clips (up to three seconds), and audio cues — and Omni 1.2 Flash holds onto those details from start to finish. Faces, garments, packaging typography, and brand colors stay consistent across camera angles, making it easy to turn existing product photography or character sheets into virtual try-on clips, catalog spins, and branded video ads.

Combining one model photo with front-and-back product shots of three outfits, Gemini Omni 1.2 Flash generates a 15-second virtual try-on sequence across 360-degree turns and match cuts while keeping the model’s identity and each garment’s cut, drape, and back details consistent.

More consistent results

You can maintain stronger character, object, and scene consistency from the first to the last frame, with less visual drift or morphing across motion and camera transitions. Whether you’re interpolating between a first and last keyframe, or extending a clip to build a longer sequence, products, characters, props, and environments stay consistent from shot to shot.

Easier editing in conversation

You can refine the same clip turn by turn — such as swapping a product or background, changing the lighting or weather, or switching the aspect ratio — instead of starting over from scratch. Multi-turn conversational editing works across full 15-second clips, making it easy to produce ad variants for different audiences and placements without re-briefing or re-generating.

More natural speech

You can generate scenes with more fluid, natural-sounding dialogue, clearer lip-sync, and distinct multi-speaker conditioning. This will show up whether you’re directing multi-character dialogue in Flow, creating video explainers in Gemini for business, or creating polished, pro videos with avatars, music and narration in Google Vids.

More controllable, cinematic look

You can direct complex, continuous camera movements like sweeping FPV flythroughs to dramatic zoom-outs and orbits with significantly fewer unwanted jump cuts, steadier scale, and a more polished, cinematic look.

Longer clips with smoother motion and tighter consistency

Gemini Omni 1.2 Flash generates clips up to 15 seconds long that hold references together better than before. You can scroll through to see characters, text, and camera moves stay consistent across longer shots, multiple turns and transitions with no cuts.

Real-world results, from creatives to global brands

Businesses, startups, and creatives are already using Gemini Omni 1.2 Flash in their workflows. And for the first time, Gemini Omni is now generally available, backed by Google Cloud’s enterprise-grade infrastructure and security. Provisioned Throughput is available, and outputs carry an imperceptible SynthID watermark.

Get started with Gemini Omni 1.2 Flash

While development is ongoing to further improve things like fast sports action, rapid script changes and complex physics, Gemini Omni 1.2 Flash is ideal for businesses, developers, and creators producing videos at scale. You can get started with Gemini Omni 1.2 Flash today as it rolls out across Google’s products and developer platforms:

  • For developers using the Gemini API: Prototype in Google AI Studio, explore interactive starter apps, and check out the developer documentation and pricing.
  • For businesses: Try it in the Google Cloud console, and build enterprise solutions with the API.
  • For everyone using Google apps: Direct scenes and multi-turn edits in Flow, generate 15-second clips at no additional cost in Google Vids with a Google account or Google Workspace subscription, create 15-second videos in the Gemini app (rolling out to Google AI Ultra subscribers), and scale video campaigns in Google Ads.
DEVOURED
Cloudflare's Trust Framework for AI Agents

Cloudflare's Trust Framework for AI Agents

AI Cloudflare
Cloudflare launched a coalition to develop standards for verifying and managing AI agents as they become a dominant source of web traffic.
What: Cloudflare introduced the Trusted Agent Delegation (TAD) coalition to address identity and accountability issues posed by autonomous agents. They also added new analytics to the Cloudflare dashboard to identify and filter agent traffic.
Why it matters: The rise of agents acting as intermediaries makes traditional IP-based filtering or rate-limiting obsolete; infrastructure providers are moving toward cryptographically verifiable identity protocols.
Takeaway: Check the new Security Analytics widget in the Cloudflare dashboard to categorize and monitor agent traffic on your websites.
Decoder
  • Intermediary: A proxy, agent, or cloud browser that sits between a user and a website, obscuring the user's original identity or device context.
  • Web Bot Auth (WBA): An emerging standard allowing agents to cryptographically sign their requests to identify the operator.
Original article

AI Agents now act on the web for millions of people. To a Site, an Agent can take many forms. It may be indistinguishable from a human user carrying out a task, or it might look like one visitor carrying many Users. This removes the ability for the Site to recognize, serve, and hold accountable the user or users behind the Agent, and causes the Site to face the costs when something goes wrong. This post argues that in order for Sites to maximize the access they provide to Agents, the ecosystem must develop new mechanisms to preserve the relationship between Sites and Users. Traditionally, in Security and Fraud Prevention, that requires three things: Identity, Reputation, and Accountability, allowing Sites to answer: Is the person acting being truthful about who they are? Is that person trustworthy? And who answers for the action?

“Personal AI Agents” (“Agents” for short) are automations that take instructions from a human (“User”) and pursue a goal by controlling a cloud computer or browser. They are usually hosted and maintained by an “Operator” as part of a managed service or consumer offering. Examples include Muse from Meta and dots from OpenAI, and more are launching all the time. Agents can potentially take any action online that their User could, without the limits that hold humans back. They don't tire, they run around the clock, they act in parallel, and they put up with friction no person would. Much of the web, from how Sites plan capacity to how they make money, assumes those limits.

Fundamentally, remotely hosted Agents are intermediaries. An intermediary is anything that sits between a User and a Site, so the Site sees it instead of the User. Agents are the newest kind of intermediary, but intermediaries have existed for a long time. Cloud browsers (hosted browsers that software controls on a User's behalf) and Proxies (services that relay a User's traffic, including VPNs) are intermediaries too. What has changed is the trajectory. Agentic traffic is growing rapidly and may eclipse traditional human browsing on the Internet in the near future. This forces a reckoning for anyone operating a Site today. Historically, a Site could simply block intermediary traffic and require Users to disable the intermediary service. That stops working when the majority of traffic is agentic. Once blocking is no longer viable, Site Operators are left with the problem that intermediaries have always created. The Site loses direct information about the User and must decide whether to trust the intermediary without it.

This post covers Agents hosted somewhere other than the User's device. Local agents (e.g. OpenClaw) or Agents running in the User's own browser, on their own device, are out of scope of the primary topic addressed by this post.

This post rests on one principle:

The Intermediation Principle: The business relationship between Users and Sites, and each participant’s security responsibilities, must be upheld regardless of intermediation.

A Site needs new tools to recognize, serve, and hold accountable a User acting through an Agent just as it could if that User had visited directly. The Agent, and the Operator behind it, must be recognizable and accountable too, because an Agent can do what no User could. Agents are able to scale human access almost without limit, so they create new risks, even for behavior that was previously benign.

The intermediary problem

Meet Ezra. Ezra works as a personal assistant for people in her city. Her best client is Amy, a local CEO, but she also works for Bob, Charlie, and Debra. She runs their errands: groceries, appointments, paperwork, and flights. Ezra blends into the crowd.

The corner grocer used to know Amy. He knew what she bought and set aside what he thought she'd like. Now only Ezra comes in, carrying orders for four people, and the grocer can't tell whose preferences are whose. He doesn't want to turn Ezra away, because she brings him a lot of business.

Then Bob asks Ezra to buy him an iPhone. A week later he calls the store, says he never authorized the charge, and keeps the phone. To win the dispute, the store has to prove Bob asked for it. But the only person the store ever saw was Ezra.

Then Charlie gives Ezra a list of passwords: "I forgot mine, but it's one of these." Ezra patiently tries each one at Charlie's bank. The bank can see an attack happening, but the only person it can ban is Ezra. Banning Ezra also bans Amy, Bob, and Debra.

None of these business owners has a problem with Ezra herself. Their problem is that they can only see Ezra, not the person she's acting for. Swap Ezra for an AI Agent and the businesses for websites, and you have the web today.

A website owner wants sufficient visibility both to prevent bad behavior and to effectively monetize or get value from their Site. But as with Ezra, much of that visibility goes away with AI Agents. Below is a list of actions that a website owner might want to address that were previously solved, but are made more challenging by allowing Agents.

Challenge Website owner’s goal
Account sharing Sites need to ensure that one paid subscription is not being abused to serve many Users. The Site sees one account and one client when accessed via an Agent.
Compliance and illegal activity A Site must meet legal requirements to verify information about its Users. For example, some Sites have age or geographic restrictions. Agents do not provide guarantees that can meet the bar for Sites to remain compliant, if they allow Agent access.
Friendly fraud Friendly fraud is when the User approves an Agent's purchase, then disputes it as unauthorized. Sites may win with circumstantial evidence: the same device, IP, and address as the User's past undisputed purchases. Agent purchases come from the Agent's infrastructure, so that evidence doesn't exist. Even when the Site wins, the dispute itself costs money. Sites need to maintain records of checkout behavior for fraud prevention purposes.
Human verification is irrelevant A Site wants to be able to distinguish the type of Users it has. CAPTCHAs and other human verification check whether the entity controlling the browser is a human or not. Agents are never expected to be humans.
Identity spoofing A Site wants to limit access to content to human Users or impose restrictions on what particular Users can access. Agents often run on residential IPs and use real Browsers, are mixed with human-directed traffic, and take efforts to not distinguish themselves from human traffic.
Identity verification breaks A Site may require additional verification of the User’s identity, or other information, in order to provide access to sensitive operations or content. Liveness checks, KYC ID checks, and similar assume the person present is the person being verified. The Agent is never that human.
Misalignment Sites may want to protect themselves from erroneous actions taken by newer or more experimental Agents. Agents make mistakes: the wrong item, the wrong date, duplicate orders.
Policy circumvention The Site is looking to impose a policy (e.g. block, allow only partners, rate limit) that is based on identity, but Agents don't always identify themselves, and they often don't bring information about the User they act for.
Resource exhaustion Sites that provide free services or that rely on User engagement were often designed with an assumed limit on User behavior. Agents poll constantly (e.g. stock and price checks), hit expensive endpoints, and use up free trials and promotions.
Risk-based authentication breaks A Site wants to maintain its risk-based authentication system, which expects the device, location, and behavior to match the User. Agents run on cloud infrastructure and look unusual every time.
Traffic commingling Sites would like to protect themselves and User accounts from abuse or fraudulent activity. When one User abuses a shared Agent for credential stuffing, scraping, or card testing, the Site can detect the abuse but can only block the Agent, which also blocks all of its legitimate Users.
Unauthorized card users Sites and payment providers need to protect cardholders from unauthorized transactions, while minimizing dispute costs and other costs related to fraud.
Uncompensated consumption Sites that monetize content require visibility and control over who accesses that content in order to apply the correct monetization model. The Agent reads or extracts content to answer the User somewhere else.
User attribution Sites offer additional capabilities to consenting Users regarding personalization, recommendations, and loyalty programs, using analytics tied to the User's session and device.

In nearly every challenge above, the Site bears the primary cost. That outcome follows from how trust works when an intermediary is involved.

Our vision

Our aim is an Internet where all Users have equal or greater access to websites than they had before. Before Agents, a Site was typically able to mitigate these risks with a collection of techniques, including fingerprinting the User’s device, session, and history. Users could still browse using private browsing mode, and we believe Agents should be able to do that as well. But they probably won’t be able to log in to a bank without additional verification.

None of this requires an Agent to act like a human or a human to be present for every action. It requires that Sites have the means to obtain or require information about the User to hold them accountable, when applicable, with or without an Agent.

What people have tried, and why they fall short

A common proposal is for Agents to pass a Site's CAPTCHA through to the User to solve. That proves some human is present at that moment (“human in the loop”, or HITL), and nothing more. HITL is primarily a mechanism to prevent mistakes from misalignment. Misalignment is an issue between the Operator and the User, and resolving it does not resolve the majority of the problems above.

Another common proposal is to use tightly scoped access controls. Agents are built to do anything a User could, so in practice they ask for, and get, permission to do everything. A scope of "everything" tells the Site nothing.

What the web needs

The web needs tools and protocols that allow Sites and Agents to collaborate to determine what behaviors and actions are allowed, as well as express preferences and policies from Sites to Agents, all in a way that can be reasonably supported by all Sites and Agents.

Protocols

Agents and Sites can engage in explicit protocols for solving some of the problems above. For instance, MOLE is one upcoming approach that aims for rate limiting without User-specific identifiers, allowing Sites to transition away from implicit identities and towards explicit protocols for accomplishing the same goal. This is similar to the x402 protocol, which aims to enable payments on the web while remaining privacy-preserving.

Identities

When discussing Agent Identity, Web Bot Auth (WBA) is our preferred method. WBA allows an Agent to sign its requests, which provides a secure way for an Agent to identify itself (and, implicitly, the Operator).

In many cases, identifying information isn’t needed, and privacy-preserving methods for moderating access to agents can help us answer “can we trust you?” without needing to answer “who are you?”.

  1. Nothing - Users may act on the internet while bringing no identifiers to the table.
  2. Session - Sites require some way of linking requests in the same session to a single agent.
  3. Account - Sites require a way of attributing requests to the same User across sessions.
  4. Unique - Some Sites might require a unique, per-User identifier provisioned by a third party that persists across Operators, accounts, Agents, and sessions.

Claims

Beyond identities, some actions require a fact about the real person, such as being over 18 or being the cardholder. Often the Operator verified this at sign-up or a third party already has this information.

Site Agent access policy

Today, an Agent infers a Site’s rules by trying something and interpreting the Site response. Sites need a machine-readable way to publish what actions Agents are allowed to do.

On open source and local Agents

Agents that are not run as an “Intermediary” (e.g. on-device Agents) raise different concerns. Primarily, they look like (and are) automation, and they have no single party to build reputation or hold accountability with.

What’s next

Real-world solutions to the problems that Sites face won’t emerge from fragmented, vendor-specific mechanisms. They require open, interoperable standards that are rooted in real world experience. We are also announcing the Trusted Agent Delegation (TAD) coalition. The goal of TAD is to bring a group of representatives across the ecosystem to have discussions on the overall problem set that was put forth in this document.

What you can do today

See which Agents are on your site, and what they're doing. Security Analytics now breaks out Personal Assistants as their own traffic category, and a new widget lists every Agent visiting your site.

Set access on your terms, per Agent. Using AI Crawler and Agent access policies, you can welcome the Agents that bring you business and restrict the ones that don't.

Tie an Agent back to the user it acts for — and act on it. For sites using Account Abuse Protection, every login and sign-up now shows whether a personal Agent made the request, and which one.

DEVOURED
NVIDIA Introduced VFlash

NVIDIA Introduced VFlash

AI Nvidia
NVIDIA VFlash introduces parallel prediction for geometric outputs, enabling robots to calculate trajectories and 3D motion without sequential token generation.
What: NVIDIA VFlash is a vision model that moves beyond traditional token-by-token generation. It produces geometric predictions such as points, boxes, depth, and 3D trajectories simultaneously to improve performance in robotics and autonomous driving.
Why it matters: Moving from sequential tokenization to parallel geometric prediction is a necessary evolution for physical world agents that require low-latency responses for real-time manipulation.
Original article

Full article content is not available for inline reading.

Read the original article →

DEVOURED
New NVIDIA Cosmos 3 Open Models for Interactive World Simulation

New NVIDIA Cosmos 3 Open Models for Interactive World Simulation

AI Hugging Face
NVIDIA released four open-weight Cosmos 3 models featuring 16 billion parameters each, specifically designed for interactive world simulation and multi-sensor data generation.
What: The Cosmos 3 platform provides researchers with open-weight models for generating photorealistic video and synchronized multi-sensor observations, which are critical for training autonomous systems.
Why it matters: Open-weight models for world simulation lower the barrier to entry for training agents to handle complex physical environments without needing to build proprietary physics engines from scratch.
Decoder
  • World Simulation: The process of creating a digital, physics-compliant environment where AI agents can train and test behaviors before deployment in the real world.
Original article

NVIDIA's Cosmos 3 platform now offers four open-weight models for interactive world simulation and driving scenes, each with 16 billion trainable parameters. These models enable multi-sensor data generation, synchronized observations, and photorealistic video from simulator controls, supporting advanced research in robotics and autonomous driving.

DEVOURED
How Primary Compute Markets Work

How Primary Compute Markets Work

AI X
Understanding compute markets requires distinguishing between reserved, on-demand, and spot pricing, each serving different roles in financing data center capital expenditures.
What: Ornn's analysis explains that hyperscalers use long-term reserved contracts to secure debt financing for hardware like NVIDIA B300s, while on-demand and spot pricing provide flexibility and capacity utilization for smaller users.
Why it matters: The shift toward treating compute as a commoditized financial asset is creating complex derivative markets where GPU capacity is traded similarly to electricity or energy futures.
Deep dive
  • Reservations: Long-term contracts that provide revenue certainty, allowing companies to secure bank loans for expensive hardware fleets.
  • On-Demand: Flexible, hourly-priced access meant for variable workloads, typically priced higher than reserved capacity.
  • Spot: Excess capacity sold at a discount that is interruptible by the provider if higher-paying demand arises.
  • Primary Market: Direct sales between data center operators and compute consumers.
  • Secondary Market: The resale of unused reserved capacity by an original contract holder to a third party.
Decoder
  • Hyperscaler: A large-scale cloud provider, such as AWS, Google Cloud, or Microsoft Azure, capable of massive infrastructure scaling.
  • Take-or-pay: A contract type requiring the buyer to pay for a specified amount of capacity regardless of actual usage.
  • SOFR: The Secured Overnight Financing Rate, a benchmark interest rate used to price various financial products.
Original article

Introduction to Compute Markets #1: The Primary Market

This is the first article in our introduction to compute markets, a series explaining how computing capacity is bought, sold, and financed. We begin with the primary market, where providers sell capacity directly to customers, and the three common ways those transactions are structured: reserved, on-demand, and spot.

Three ways to sell compute on the primary market

Congratulations! You’ve just received a quote for 1,024 NVIDIA B300s. Soon, you could be renting the chips to customers training AI models, serving inference, and more.

Unfortunately, buying the B300s requires more money than you have on hand. You’ll need a loan, and the lender wants to know how you’ll earn enough from renting the GPUs to cover operating costs and repay your principal plus interest. Once the cluster is running, those bills will come due whether customers are using the GPUs or not. Before committing to the purchase, you need a plan for who will rent your capacity, at what price, and for how long.

On the “primary” market, where compute is sold directly from data centers to compute consumers, there are three types of distribution:

Reservations

To begin, you can sell via reservation, where a customer commits to capacity for an agreed period of time. In fact, a long-term reservation could help secure the financing needed to purchase and deploy your GPUs.

Originally, when you approached the lender, you were equipped with projections of what customers might pay to rent your B300s, but no contracts committing them to do so. The lender responds: if rental prices fall or the GPUs sit idle, how can we be confident the loan would be repaid?

To credit investors, companies like yours—with uncertain cash flows—are considered “junk.” In nicer words, your company is bucketed as “high-yield” because you’re more likely to default. As the name suggests, this means that you’ll need to pay much higher interest on your loans, if you’re able to secure a loan at all. In this case, the rate your lender demanded made financing the GPUs too expensive for the project to work.

What do you do?

To get better financing terms, you need to give the lender more confidence you will generate enough revenue to repay the loan. So, you approach an old friend managing compute at a hyperscaler, and you give them a proposal. The hyperscaler—a creditworthy offtaker with a deep balance sheet—commits to paying for 640 of your B300s for five years, and in return, you commit to making those GPUs available for its use 99.9% of the time once the cluster is delivered and accepted. The hyperscaler agrees, and the promise is set out in a service-level agreement, or SLA. If your downtime exceeds that allowance, you’ll owe the hyperscaler service credits, or even give it the right to terminate the contract.

In this case, the hyperscaler signs a “take-or-pay” contract, agreeing to pay $4 per GPU-hour for all 640 B300s throughout the five-year term, whether it uses them or not. It plans to train models around the clock, so it expects to use most of the hours it’s buying. When it doesn’t need the full cluster for training, it can put the remaining capacity toward research experiments or serving models through inference.

With the hyperscaler as your “anchor tenant,” you return to the lender. This time, you bring a contract committing the customer to $22,425,600 a year in payments ($4 per GPU-hour across 640 GPUs, 24 hours a day, 365 days a year). You still need to deliver the cluster, meet your service commitments, and manage operating costs but—provided you perform and the hyperscaler pays—your revenue is now partially immunized to the uncertain price of GPU-hours.

Hence, the lender is now willing to give you a delayed draw term loan at SOFR + 5%, which you use to buy your 1,024 GPUs, with the GPUs themselves serving as collateral. Mission accomplished.

By selling through reservation, you are effectively sacrificing the potential upside on 640 of your GPUs if B300 rates rise, because you’ve already locked in a price. On the other hand, you now have the necessary customer revenue to finance the cluster.

We’ve used a five-year reservation to show how a customer contract can help finance your cluster, but reservations can also last a month, a year, or another agreed period. Generally, the longer a customer commits, the lower the hourly rate it can negotiate. You gain more certainty about future revenue, while the customer gets a discount for agreeing to keep paying even if its compute demand changes or rental prices fall.

On-Demand

With 640 of your 1,024 B300s reserved by the hyperscaler and financing secured, you still have 384 GPUs available to rent. What do you do with them?

You could find another long-term tenant, but you’ve already secured the financing needed to deploy the cluster, and you’re bullish on B300 rental rates. Keeping some capacity uncommitted would let you charge higher rates if prices rise over the next few years.

So you decide to sell some compute capacity “on-demand.” Here, customers rent your available GPUs without committing to a fixed term and release them when they’re finished. Rates are quoted per GPU-hour, and charges are often calculated by the second or minute. You charge a higher hourly rate for on-demand rentals than for reservations in exchange for this immediate access and flexibility.

Who are the buyers of on-demand? Any company with variable token usage.

A reinforcement learning provider, for instance, helps AI companies adapt open-source models to specific workloads. Customers pay for individual training runs or projects, without necessarily committing to ongoing work. If the provider reserves GPUs for several years, it will have to keep paying for them long after those projects end, unless it can find enough new business to fill the gap.

Consider one of its customers, a legal AI startup adapting a model to review contracts. The provider rents two eight-GPU B300 servers to run several training experiments in parallel. Once the team has compared the results and narrowed its approach, it continues on one server and releases the other. Once the project ends, it can release the remaining GPUs too.

Renting on-demand lets the provider adjust its compute spending as the revenue supporting that spending changes. It pays a higher price for each GPU-hour but can stop buying hours it no longer needs. It can also take on new customers without first funding a larger fleet or committing to years of rental payments on the strength of their forecasts. Hence, for this reinforcement learning provider—and many other AI companies—the flexibility of on-demand is worth the higher cost.

As the reinforcement learning provider builds a steadier pipeline of projects, it may rent enough GPUs via reservations to cover the demand it can reliably expect and rent additional capacity on-demand during busier periods. Electricity retailers take a similar approach, securing part of their expected demand through long-term contracts and buying the rest at short-term prices. Combining the two lets suppliers optimize their balance sheet risk and flexibility.

Spot

After narrowing its training experiments, the reinforcement learning provider releases one of your eight-GPU B300 servers. You offer them to other customers on-demand, but nobody is renting them at your current rate. For now, they sit idle.

An academic researcher happily offers to rent those GPUs, but has a limited budget. You offer a deal at, say, half your on-demand rate. In exchange, the researcher agrees that you can stop its workload and reclaim the GPUs at short notice if another customer needs them. This is spot compute; the rental is cheaper because it is “interruptible.”

A few days later, an inference provider wants to rent eight B300s on demand. You notify the researcher, stop its workload, and reallocate the GPUs to the new customer. The researcher can resume when spot capacity becomes available again.

For you, spot earns revenue during hours that would otherwise go unsold, while preserving the ability to reclaim the machines for more valuable on-demand customers.

What Ornn’s indices measure

As this article shows, GPU pricing differs across reserved, on-demand, and spot arrangements, even when the hardware is the same. The Ornn Compute Price Index (OCPI) measures specifically on-demand GPU rental prices in USD per GPU-hour, using only executed transactions. Reserved and interruptible spot rentals are excluded. The OCPI H100 and B200 benchmarks underpin the corresponding monthly cash-settled GPU compute futures contracts on ICE Futures U.S.

When customers become sellers

So far, you’ve sold access to your precious 1,024 B300s directly to customers. However, a year into its five-year reservation, the hyperscaler’s plans change. It no longer needs all 640 GPUs, yet remains committed to paying for them.

If its agreement permits, the hyperscaler decides to recover some of its cost by reselling access to the capacity it no longer needs. Another customer uses your GPUs, while the hyperscaler continues paying you under the original reservation.

That resale takes us into the secondary compute market, the subject of our next article.

DEVOURED
The Ultimate MoE Training Handbook

The Ultimate MoE Training Handbook

AI Hugging Face
Hugging Face has published a comprehensive manual detailing the technical requirements and best practices for training mixture-of-experts (MoE) models.
What: The guide covers the architecture, training strategies, and optimization techniques necessary for building high-performing MoE models.
Why it matters: MoE is becoming the standard architecture for high-performance LLMs because it allows for high parameter counts while keeping inference costs relatively low through sparse activation.
Decoder
  • Mixture-of-Experts (MoE): A neural network architecture where only a subset of parameters (experts) is activated for any given input, reducing compute costs.
Original article

Hugging Face released "The Ultimate MoE Training Handbook," a comprehensive guide on training mixture-of-experts models.

DEVOURED
Devin Review 2.0

Devin Review 2.0

AI Devin
Cognition AI has reduced the cost of its automated pull request review tool by 82%, aiming to make AI code review a standard CI step.
What: Devin Review 2.0 now costs between $0.25 and $0.75 per PR and includes incremental review support, custom reviewer rules for security or performance, and an 'Ultra' mode for sensitive codebases.
Why it matters: By slashing costs to sub-dollar levels, Cognition is attempting to commoditize AI-assisted code review, positioning it as an essential CI utility rather than a premium, occasional service.
Takeaway: Try adding '/devin review' to your pull requests on GitHub or GitLab to test the automated feedback and bug detection features.
Deep dive
  • Reduces average cost per PR by 82% compared to August
  • Increases bug detection rates from 1.22 to 1.32 findings per PR
  • Implements incremental review to process only changed code, reducing noise and cost
  • Introduces Custom Reviewers in beta to enforce internal standards like secure DB migrations or accessibility
  • Adds 'Devin Review Ultra' for deep-dives into high-risk code segments
  • Decreases median review latency to 94 seconds
Decoder
  • SDLC: Software Development Life Cycle; the end-to-end process of planning, building, testing, and deploying software.
  • CI: Continuous Integration; a practice of automatically merging code changes into a central repository to run tests.
Original article

Today we’re introducing Devin Review 2.0, which makes Devin Review the default tool for PR review when working with Devin.

Since August, we’ve cut the cost of reviewing a PR by 82%. A typical review now costs just $0.25-$0.75, making Devin Review cheap and effective enough to run on every PR.

On average across our customers, each bug that gets fixed costs about $2.25.

In this post, we first discuss why review matters more today than ever before. Then we dig deeper into Devin Review’s new cost profile, explore how Devin Review works with Devin, and introduce its latest improvements.

Code review is the bottleneck

The throughput of PRs is increasing, but our capacity for manual code review is not. Code review—the step immediately after PR creation—has become the new bottleneck of the SDLC.

One way to overcome this problem is to stop reviewing PRs or review fewer PRs. However, while this brings short term gains in throughput, it has long term costs in customer-facing bugs and code quality.

A better way to overcome this problem is to use agents to assist with review. Devin Review finds bugs automatically to make all PRs safer. It also produces a guided tour of the PR, so that the human review is faster and has more context.

5x cheaper since August

Since August, the cost of a Devin Review per PR has dropped by 82%. These savings came from a better mix of models across Devin Review and from harness optimizations.

Quality did not suffer. After the cost cuts, Devin Review found more bugs per PR, up from 1.22 to 1.32 on average.

Automatically review every PR

You can run Devin Review on individual PRs with a /devin review comment in GitHub or GitLab. You can also start one from the Devin Review page in Devin Cloud or Devin Desktop.

You can also choose to automatically run Devin Review on your PRs once they are ready for review. Much like CI, this ensures that fewer bugs get merged into your codebase. And this makes it so that when your developers open a fresh PR, there is a completed review with feedback waiting for them.

Devin Review supports using fine-grained rules to decide when a PR should be reviewed. You can choose to run Devin Review on draft PRs; or filter by file paths, branches, labels, and more. Our customers use these rules to minimize their spend by excluding low-value PRs.

Incremental PR reviews

When run again on the same PR, Devin Review now incrementally reviews only the parts of the PR that have changed. This applies by default to every PR. This has two benefits:

  1. New findings are focused on the latest changes, reducing noise.
  2. Costs are greatly reduced, as each push is smaller than the whole PR.

About 80% of PRs cost less than a dollar to review, including all pushes. Devin Review also has a configurable per-PR spend limit, so a runaway PR can’t run up the bill.

Devin Review’s automatic review rules can be set to run on every push. This allows Devin Review to find new bugs as the PR evolves and to refresh the guided tour. One-off reviews are helpful, but miss a large part of the PR lifecycle.

Fix bugs faster with Devin

Devin Review can review PRs from all sources, but it works best with Devin.

When you use them together, Devin investigates each finding and decides whether to fix it, dismiss it, or escalate it to you. By the time you return to the session, the only things left are the bugs and decisions that need your attention.

We have also made Devin Review 1.5x faster since August, with a median latency of 94 seconds, down from 139 seconds.

Make Devin Review work for you

We’re also introducing two features that give you more control over how Devin Review runs and what it looks for.

Effort levels

By default, Devin Review is tuned to be cost efficient. But in some parts of your codebase, such as billing or security-sensitive code, a missed bug costs far more than a review.

For those areas, we’ve added Devin Review Ultra, an effort level that runs a more thorough review at a higher cost.

Custom reviewers

By default, Devin Review looks for bugs. But many teams also have specialized checks they want to run on every PR, which look very different from a bug-finding pass.

Custom Reviewers, now in beta, let you turn those checks into reviewers that run inside Devin Review, using your own instructions. Internally, we run custom reviewers to enforce backend security practices, safe DB migrations, performant SQL queries, and accessible UI components.

Each custom reviewer can have its own automatic review rules. Its findings appear in your Devin Review results and flow into Devin’s automatic fixing, and it follows the same cost controls as the rest of Devin Review.

Learn more

Try Devin Review on your next PR, or read the documentation to learn more.

DEVOURED
Blue Origin says it is building a higher-performing rocket engine at 1/4 the cost

Blue Origin says it is building a higher-performing rocket engine at 1/4 the cost

Tech Ars Technica
Blue Origin is testing its Northstar engine, a 3D-printed upgrade intended to cut manufacturing costs by 75 percent compared to the current BE-4.
What: CEO Dave Limp announced that Blue Origin is developing the Northstar engine—featuring half the parts of the BE-4 and significant 3D-printed components—alongside a new composite-tank third stage (GS3) for the New Glenn rocket to support 2028 cislunar missions.
Why it matters: By verticalizing and simplifying engine production, Blue Origin aims to turn rocket launch into a high-cadence, low-cost commodity, directly challenging SpaceX's dominance in launch frequency and cost-efficiency.
Deep dive
  • Northstar Engine: Simplified, 3D-printed methane/LOX engine with 715k lbs thrust compared to BE-4's 640k lbs.
  • GS3 Stage: New third stage for New Glenn using composite liquid hydrogen tanks, designed for direct geostationary or translunar injection.
  • Manufacturing: Target of assembling Northstar engines in under one day, with 65% of parts 3D-printed.
  • Capacity: GS3-equipped New Glenn variant targets 14 metric tons to geostationary orbit or 20 tons to translunar injection.
Decoder
  • Geostationary orbit (GEO): A circular orbit 35,786 km above Earth's equator where satellites remain fixed relative to a point on the surface.
  • Translunar injection (TLI): A propulsive maneuver used to set a spacecraft on a trajectory toward the Moon.
  • Staged combustion cycle: A high-efficiency rocket engine design where exhaust from pre-burners drives turbopumps before main combustion.
Original article

KENNEDY SPACE CENTER, Florida—Blue Origin announced two significant upgrades to its New Glenn rocket on Thursday, reducing the cost of manufacturing the vehicle and expanding its capacity for payload delivery to geostationary orbit and the Moon.

With these upgrades, the company aims to eventually position New Glenn to launch more than 1,000 times a year.

“There has never been higher demand for launch, ever,” Dave Limp, chief executive officer of Blue Origin, said during the UP.Summit conference at the Shuttle Landing Facility in Florida.

Blue Origin has already begun test firing a new engine, called Northstar, that will eventually replace the BE-4 engine that powers the first stage of New Glenn. Separately, the company also said it was developing a hydrogen-oxygen third stage for the rocket, GS3, to give it an extra kick.

A new Northstar

The Northstar engine is a simplified but more powerful version of the BE-4 engine, Limp said. It has half the number of parts and 30 percent less mass, and about 65 percent can be 3D-printed.

Blue Origin believes it can manufacture the engine at 25 percent of the cost of a BE-4 engine and eventually reach the point where each engine can be assembled in less than a day. The company is deep into development and testing of Northstar, having already begun a test-firing campaign.

“To get access to space at a lower cost, we have to look at every part of the vehicle,” Limp said. “This is going to be a game-changer.”

The BE-4 engine powering New Glenn today has a thrust of 640,000 pounds, and Limp said Northstar will have a starting thrust of 715,000 pounds. Like the BE-4 engine, Northstar burns methane and liquid oxygen using an oxygen-rich staged combustion cycle and a single-shaft turbopump architecture.

Limp said the company will continue to manufacture the existing BE-4 engine for United Launch Alliance, which uses two of the engines to power its Vulcan rocket.

GS3 provides a nice kick

Blue Origin is developing a third stage for New Glenn called GS3 (creatively named Glenn Stage 3) to offer direct injection to geostationary orbit and Earth-escape trajectories. The third stage fits within an interstage, preserving the full fairing volume for customer payloads.

The stage can fly on both the smaller 7×2 variant (as in, seven first stage engines and two second stage engines) of New Glenn as well as the larger 9×4 variant. According to Blue Origin, a GS3-equipped New Glenn 7×2 can carry 8 metric tons directly to geostationary orbit and 10 metric tons to translunar injection. Those figures increase to 14 tons and 20 tons, respectively, for the larger 9×4 variant.

As the rocket’s third stage, it needs to be light, Limp said. For this reason, the third stage is made mostly of composites, which are high-performing and lightweight. But there’s a problem with that.

The trouble with hydrogen

The stage will be powered by the company’s BE-7 engine, already used by its lunar landers. This engine is optimized for in-space operations and uses liquid hydrogen and oxygen propellants. But hydrogen is the smallest atom and therefore leaky. With composites, thermal cycling and mechanical strain can cause cracking, exacerbating losses of molecular hydrogen.

Limp said the company was not sure a large composite tank, 5.5-meter diameter in this case, could be constructed that would contain hydrogen at high pressures.

The company recently had a breakthrough at Launch Site One in Texas, when it completed its first composite liquid hydrogen tanking test. During the test, the tank was pressurized to 100 percent of the maximum force expected during operation for 2.5 hours. It was even successfully tested at 150 percent of this maximum pressure for 10 minutes.

That gave the company confidence that a GS3 based on composite tanks was a concept that could go forward, and now the company is aiming for a debut in 2028 for a government customer.

“We have one customer signed up for cislunar space in 2028,” Limp said. “We are open for business.”

DEVOURED
Inside GitHub's new Git storage architecture

Inside GitHub's new Git storage architecture

Tech Github
GitHub is rolling out a new Git storage architecture designed to handle thousands of concurrent writes and scale reads for agentic development workflows.
What: GitHub's new architecture supports up to 5,000 concurrent agents per repository by separating concerns, specifically addressing the high-frequency access patterns generated by AI coding assistants.
Why it matters: As AI agents become primary drivers of code changes, legacy git storage—which was built for occasional human commits—becomes a performance bottleneck, necessitating this shift to a more granular, high-concurrency model.
Deep dive
  • Concurrency: Supports 5,000+ concurrent agents per repository.
  • Performance: Optimized for high write throughput (thousands/second) and low-latency reads.
  • Agentic Shift: Redesigned specifically to accommodate AI agents that manipulate codebases autonomously, moving away from human-speed commit cadences.
  • Storage Design: Move toward a more distributed, scalable storage backend to decouple repository health from individual agent activity spikes.
Decoder
  • Agentic development: Software engineering workflows where AI agents autonomously perform tasks like bug fixing, refactoring, or feature implementation across a repository.
Original article

GitHub's new Git storage architecture is capable of handling thousands of writes per second with reads that scale on demand. It can support 5,000 concurrent agents working on a repository while serving read traffic with consistently low latency. The new architecture is designed to support agentic development for hundreds of millions of developers. This post walks through the requirements behind the design of the new architecture and explores two of its components.

DEVOURED
The Hackintosh Reborn... with AI

The Hackintosh Reborn... with AI

Tech Naut.ca
AI-assisted coding and new emulation tools have sparked an unexpected resurgence in the 'Hackintosh' community.
What: Developers are successfully running macOS 27 and iOS 17 on non-Apple hardware, including Snapdragon laptops and Nintendo Switch OLEDs, using AI tools like Claude Code and OpenAI Codex to navigate the complex implementation tasks previously requiring years of specialized expertise.
Why it matters: AI tools significantly lower the barrier to entry for complex reverse engineering and integration, allowing hobbyists to perform system-level tasks that were previously only accessible to highly skilled, dedicated teams.
Decoder
  • Hackintosh: The process of running Apple’s macOS operating system on hardware not manufactured by Apple.
  • SBC (Single Board Computer): A complete computer built on a single circuit board, such as a Raspberry Pi or the RK3588 mentioned here.
Original article

The Hackintosh Reborn... with AI

A "Hackintosh" is the feat of running macOS on non-Apple hardware, and has a history dating back to the late 1980s. Almost a decade ago, I released a hackintosh guide on running macOS 10.14 through a VM with an x86 host. At the time KVM and PCI passthrough were relatively new technologies, and this guide allowed near-native performance with GPU acceleration.

A few years passed by, and we saw Apple release the first ARM-based Mac in 2021, the M1 MacBook Air. The timing was impeccable, Intel was unable to create competitive processors (due to being stuck on the 14nm node), and Apple had powerful and efficient ARM chips already being shipped in their iPhones. The long battery life, the fanless design, the instant wake, what's not to like? The benefits of switching to ARM were clear, however to most, this was thought to be the final chapter in the hackintosh community. x86 versions of macOS would soon be discontinued, and the hackintosh community would slowly fade away. The latest version of macOS 27 (Golden Gate) was released this year, and is no longer compatible with x86...

Just a few days ago, I decided to create an iOS app for the first time. It required XCode 26 for development, so I used my spare ThinkPad T490 as my development machine and installed macOS 26 using a posted guide. The installation was smooth and painless. XCode 26 has integrations with Claude Code and OpenAI Codex, and this was my first foray into AI-assisted coding. After some initial tinkering with x86 workarounds, I was pleased that I had a functional iOS app within a day, without touching a single line of code!

So how does this all tie in? Well, this is exactly what the Hackintosh community could hardly envision five years ago: the rise of AI. Waiting patiently and gently until now, the hackintosh and the hackios community has seen an absolute explosion in development, activity, and success in the past few weeks! As one person aptly wrote, this is the power of Claude Code with Ghidra on steroids. To list a few recent developments, we have:

macOS 27 running on the Snapdragon Laptop:

macOS 27.2 Beta on an ARM SBC RK3588 with Mali drivers:

iOS 17 running on the Nintendo Switch OLED:

Support for 50-series Nvidia GPUs with nullmoth:

I'm barely scratching the surface, with further developments in AirDrop, accelerated video decode, and even running translated macOS 27 on x86. As much as we lament the cost of AI, there are some glimmers of hope: you just might be able to have your hardware and own it too.

DEVOURED
100x more programmers

100x more programmers

Tech Tailscale
AI will turn a billion people into programmers, but we must ensure this doesn't lead to total vendor lock-in with cloud-based AI stacks.
What: Avery Pennarun of Tailscale argues that AI will empower non-traditional programmers to build custom tools, but warns that current AI trends favor vertically integrated stacks that trap users in proprietary ecosystems. He proposes that open, interoperable systems are necessary to maintain user sovereignty.
Why it matters: The industry risks repeating the 'cloud mainframe' mistake, where companies trade control and portability for the convenience of an integrated provider-hosted AI toolchain.
Deep dive
  • Democratized Coding: AI allows individuals to create software for tiny, specific use cases that were previously ignored by professional software economics.
  • Networking Bottleneck: Even when AI writes code, the 'localhost' problem—hosting, identity, and networking—remains the primary obstacle for deploying simple applications.
  • Vendor Lock-in: AI companies are incentivizing users to adopt their model, agent, tools, sandbox, and hosting as a single, inseparable bundle.
  • Open Platforms: Interoperable interfaces allow for a modular approach where model providers, compute resources, and networking layers can be replaced independently.
  • Sovereignty: True sovereignty in AI requires the ability to switch providers without discarding the entire software stack.
Decoder
  • Tailnet: A private network overlay created by Tailscale that allows devices to connect securely as if they were on the same LAN.
  • NAT (Network Address Translation): A method used by routers to map multiple private IP addresses inside a network to a single public IP, which historically makes direct peer-to-peer connections difficult.
Original article

100x more programmers

I think there are going to be about 100 times more programmers in the next few years. About a billion people.

Most of them won’t call themselves programmers. They won’t know Python. They won’t care whether their app uses React or SQLite. Many of them will never look at the source code. They’ll have an idea, tell a computer what they want, and the computer will make it.

That’s programming.

We got a glimpse of this at a Tailscale offsite earlier this year. Sandy, who works in our CEO office, was running an activity and needed to flip a coin. Nobody carries coins anymore, so she downloaded a coin-flipping app from the App Store. It worked, except every few flips it played an ad. More than a hundred people sat there waiting for a fake coin to finish monetizing itself.

Later, a couple of people from the Aperture team showed Sandy that she could make her own coin-flipping app with AI. Sandy isn’t a programmer in the traditional sense, but that turned out not to matter very much. Once she was at the terminal prompt, she described what she wanted and the AI made it. One of our engineers watching her said he recognized the expression on her face. She experienced the same feeling he’d had when he was twelve and first got a program to compile.

"Welcome to programming," he told her. "You’ll be chasing that high for the rest of your life."

The messy part was everything that had to happen before Sandy reached the prompt. Somebody helped set up a Linux VM, connect to it, configure SSH, and start the coding agent. Then someone had to explain localhost, a rite of passage in web programming: the app is running, it works perfectly, and nobody else can see it.

We have computers that can write computer programs now, an absurdly hard problem. And then we get stuck on localhost.

That tells us everything about what has to happen next.

A billion small programs

Two years ago I wrote The New Internet, my attempt to explain Tailscale beyond "VPNs, but nicer."

We can go back further, to David Crawshaw’s Remembering the LAN. Crawshaw wrote about growing up above his father’s medical practice in the 1990s. His dad was a doctor and a part-time programmer. He wrote software for the practice because he knew exactly what the practice needed, and because a program running on a small LAN could be simple enough for one person to build and maintain. It didn’t need a product team or a cloud architecture. It was a small program, written by the person who understood the problem, for the people who needed it.

That style of programming is mostly gone now.

Which is strange, because almost everything about computers got better. Programming languages got easier. Computers got faster. The Internet connected everyone on Earth. But somewhere along the way, making a small piece of software for six people became impossible. We can only do Serious Infrastructure Projects now, because everything has mandatory complexity.

Professional developers learned to work around the complexity. Everyone else mostly stopped trying, and started buying software instead. The little tool for twelve people became a subscription, and over time we traded the ability to shape our own software for the convenience of using whatever somebody else had already built, because it’s supposedly expensive to make our own.

AI changes software economics. A program can now be worth making, even when the audience is one person. A teacher can make something for one class. A dentist can make something for one office. Somebody can make a tool for one project at work, use it for a month, then forget about it. There doesn’t need to be a startup, a venture capitalist, a product manager, a pricing page, or a total addressable market.

Professional programmers are already benefiting from the revolution. Coding agents can turn their ideas into working code faster than ever. AI doesn’t remove judgment, testing, or taste. It just makes getting from an idea to reality much easier.

But I’m still waiting for the bigger change, which comes when the people doing this aren’t professionals anymore.

When making a tiny program is easier than searching the App Store, filtering out spam products, making an account, paying for another subscription, and sitting through the ads, more people are going to make tiny programs. Lots of them.

Programming got easier. Computing didn’t.

There’s an old triangle underneath almost every computing architecture: compute, storage, and networking. The program has to run somewhere, the data has to live somewhere, and the pieces have to communicate.

AI has made remarkable progress at translating human intent into software. But that old triangle still haunts us.

In fact, once writing the code gets easier, it becomes more obvious. Sandy didn’t get stuck writing the application. She got stuck giving it a computer, connecting to that computer, and sharing the result.

This was our original Tailscale thesis. We thought developers were scaling things they didn’t need to scale. When we traced that complexity backward, networking was the cause. Networking was too hard, and too dangerous by default.

A computer behind NAT couldn’t reliably accept a connection from another computer, so you put a server in a data centre. Then you needed a static public IP address, an open firewall port, DNS. Then TLS. Then authentication. Oops, make sure your auth library isn’t buggy. Where do the accounts come from? Do we need passwords and an email recovery flow? And oh, maybe now you need a team of SREs to keep this whole mess alive.

None of those decisions seemed crazy. They’re standard practice now. But they never used to be, not for tiny apps. They accreted, by accident, as we stacked half-solutions on problems that started at the very core of computing.

Tailscale digs down and begins to fix the core problems. Now a laptop, VM, phone, or Raspberry Pi can have a stable identity and make an encrypted connection directly to any other device you want. You can share a machine with someone outside your tailnet without publishing it to the Internet. Software can even embed Tailscale directly with tsnet instead of expecting a human to configure the network first.

Once that works, where the program runs becomes a much less dramatic decision. And you can start choosing differently.

Your laptop is a computer. So is the old Mac mini or Raspberry Pi in your basement. So is a machine at work. If the program needs better uptime, move it to a cloud VM. If it grows into the next Google, okay, do some infrastructure.

But the first coin flip probably doesn’t need all that stuff. It might not even need Spanner at all!

The next billion programmers aren’t going to tolerate the professional software stack just because professional programmers learned, through constant trauma, to live with it. They won’t be impressed that Kubernetes can schedule the coin-flipping app across three availability zones. (Note: Ha ha! Do not actually let k8s schedule across availability zones. You’ll have to do that some other way.)

The 100x as many programmers will wonder why the computer couldn’t just run the thing it made.

And they’ll be right.

Don’t rebuild the mainframe

There is a very easy, but dangerous, way to hide all this complexity from the user: give it all to one company.

We’re already heading in that direction because that’s the default. We’ve spent the last 20 years learning to expect it.

People talk about AI as though the model is the product, but a model is only one part of a working system. Something has to provide the interface, decide what context to send, connect to source code, files, Slack, databases, and APIs, run code safely (somewhere), manage credentials and permissions, and control what can talk to what.

Naturally, the AI companies are building outward. The model gets an agent. The agent gets tools and connectors. Then come sandboxes, hosting, identity and enterprise controls. Each new piece makes the next one easier to buy from the same company.

From the provider’s point of view, this is entirely rational. Frontier models are expensive to build, so once you’ve spent that much on the model, of course you want to sell the agent, tools, hosting and everything else around it too. And as a bonus (for the provider), every new layer adds vendor lock-in.

You start with an API call because it’s the easiest way to try the model. Then the agent uses that provider’s tool format, then its connectors, then its sandbox because everything already fits together. Security approves the setup. Your team builds workflows around it. They host provider-hosted apps in provider-branded sandboxes using a provider-branded frontend.

None of those decisions feels like lock-in when you make it, but they add up. A year later, changing the model means moving all your apps and retraining your entire company. Oops.

We’ve seen this movie already. The cloud started as an easier way to rent a computer. The computers were all interchangeable; rent them from whichever cloud has the best prices and reliability! But that all changed.

The magic words here are "value add." Cloud providers added a lot of value on top of those rental VMs: databases, identity, queues, observability, serverless functions, security products and hundreds of other things that work exceptionally well together. But only if you never leave.

It’s a real dilemma! All those things are legitimately valuable. But the whole is less than the sum of its parts. The lock-in kills competition, and competition is where innovation comes from.

In the AI world, it can happen again, even faster, if you let the model become the interface to everything else. It doesn’t just use the surrounding tools. It recommends them, configures them, and starts using them, sometimes without you making any explicit choice.

Meanwhile, outside the trillion-dollar companies, models are improving and prices are falling much faster than alternative cloud pricing ever did. The model that looks indispensable today will be overtaken, matched, or undercut six months from now. Sometimes paying for the frontier model is absolutely worth it. Sometimes a much cheaper model does the job just fine.

You won’t know for sure until you try. So the game is, stop you from trying.

This reminds me of the story of Prometheus. Zeus took fire away from humanity. The unappreciated detail in the Prometheus story is that he stole it back from the gods and gave it to everyone.

In the modern version, these models were trained on the accumulated writing, code, science, and art of humanity. Now a handful of companies are packaging that capability inside systems only they control. Zeus stole the fire first.

I think we should steal it back.

Not the models themselves, there are plenty of good free ones already. But the ability for anyone to have an idea, make a computer build it, then run, move, and change what they built, anywhere and anytime they want, without asking one company for permission.

Open systems can still feel integrated

There is a persistent belief in the technology industry that you have to choose between integration and openness. One company can give you a polished system where everything fits together, or you can jumble together a half-working combination of self-hosted open source in your homelab.

I don’t buy it. We used to build good open systems. Our lost faith in that possibility is a kind of propaganda.

The Internet itself is a pretty good example. A Mac can connect through a router from one company, across networks run by several others, to a Linux server in another country, then display the result in a browser made by somebody else. The pieces work together constantly. Nobody had to own all of them.

The trick is having good interfaces.

Models, harnesses, sandboxes, connectors, identity systems, and compute providers should all be replaceable components. Replaceable does not mean identical. It means changing one part shouldn’t require throwing away every other part.

That idea is a key part of the vision behind Aperture. The model should be one component in the system, not the centre of gravity for everything around it. Aperture lets people and organizations put different model providers behind the same identity, policy, and access controls, so the model can change without rebuilding the rest of the stack.

Boundaries and interfaces matter for security. The lethal trifecta is a useful example: an agent becomes dangerous when it can combine untrusted input, private data and unrestricted network access. The answer is to control what the agent can reach, what it can read and where it can send data, regardless of which model happens to be running underneath.

The response to AI lock-in can’t be another vertically integrated stack with a different logo on it. If one company still owns the model, interface, sandbox, network, compute and data path, the underlying problem hasn’t changed.

A good platform gives up control. Customers might replace your component. Competitors might plug into the same system. Someone might build a combination you never anticipated. That’s not a failure of the platform. That’s what makes it a platform in the first place.

Tailscale has always been built around that idea. We don’t need to carry every packet or own every service connected by the network. The same should be true of the AI stack. The model can come from one company, the compute and storage from another, and the network from somewhere else. Some pieces can be commercial services, some open source, some operated by the customer.

And once you have that freedom, location becomes a choice too.

Sovereignty means having somewhere else to go

Canada, Europe, and plenty of individual companies are talking about AI sovereignty. If your country’s companies, governments, hospitals, and researchers depend on foreign AI providers, then your economy operates at the whim of someone else.

The current response seems to be to recreate the whole stack domestically, in each country. Train a Canadian frontier model on Canadian GPUs in a Canadian data centre, serve it through a Canadian cloud, and keep everything inside the border.

There are cases where that makes sense. Canada should have frontier AI companies. It should have research computers available. It should have data centres. Canada’s national AI strategy is right to care about that capacity.

But sovereignty gets much easier once we stop treating the entire AI system as a single indivisible object.

Where a model was trained, who owns it, where inference runs, where customer data lives, who controls the application, and which country’s laws govern the provider are separate questions. You have sovereignty as long as you maintain the ability to walk away.

An open-weight model trained in China can run in Toronto. The Canadian customer’s data doesn’t need to go to China. A Canadian model can run in Germany. A Canadian inference provider can compete with an American one while using a model neither company trained.

Tailscale is Canadian, I’m Canadian, and I want my own country to get this right. Canada probably isn’t going to outspend the giant US AI companies, but it doesn’t have to. It can get very good at making the open version as easy to use as the centralized one.

If Canada can do it, so can you. A European provider can do the same thing under European jurisdiction. Another provider can specialize in cheap open models. Another can compete on latency or a particular workload.

And then we have a real market.

That’s better for resilience because there is more than one supplier. It’s better for trade because countries can provide the components they’re good at instead of reproducing the entire stack. Sensitive workloads can remain under local control without requiring every country to build every layer itself.

And suppliers have to keep earning the business.

Competition works much better when customers can leave.

100x more owners

For the last couple of decades, we’ve gradually stopped treating personal computers as computers. A MacBook Pro has more CPU, GPU, memory, and storage than machines we called supercomputers as recently as 20 years ago. But we mostly use it as a very fancy terminal connected to somebody else’s cloud mainframe.

A new generation of AI-built software gives us a chance to rewrite the future.

I still like the cloud. I like frontier AI models too, they’re amazing. Sometimes somebody else’s computer is exactly the computer you want.

I just don’t want it to be the only computer you and your agent are allowed to use.

DEVOURED
Powering open infrastructure for autonomous agents

Powering open infrastructure for autonomous agents

DevOps Google Cloud
Google has donated its agent-specific infrastructure stack—Agent Substrate, gVisor, and OpenRL—to the CNCF to standardize how autonomous agents scale and execute code.
What: The CNCF Sandbox accepted Agent Substrate, gVisor, and OpenRL from Google. Agent Substrate is now generally available on GKE, providing a way to decouple stateful agent sessions from compute to achieve 10x container density and sub-500ms restoration of idle agent sessions.
Why it matters: The industry is moving away from keeping persistent containers alive for idle AI agents; this stack enables 'serverless' behavior for agents, allowing them to pause and resume without tying up compute resources.
Deep dive
  • Agent Substrate: Separates stateful 'Actors' from a pool of 'Workers', allowing agents to hibernate during model inference turns.
  • gVisor: An application kernel written in Go that provides secure sandboxing for untrusted code execution without requiring full virtual machine virtualization.
  • OpenRL: A library for orchestrating reinforcement learning loops directly on Kubernetes, using Dynamic Resource Allocation to share GPU time between training and inference.
  • Density: By snapshotting idle agent states, the system can pack 10x more agents onto the same underlying hardware compared to standard container approaches.
Decoder
  • CNCF Sandbox: A maturity level for early-stage open-source projects hosted by the Cloud Native Computing Foundation.
  • Reinforcement Learning (RL) post-training: A process where models are tuned by performing millions of tasks in a sandbox and scoring the outcomes to update model weights.
  • gVisor: A user-space kernel that intercepts system calls, providing a strong security boundary for running untrusted code within containers.
Original article

Powering open infrastructure for autonomous agents

As AI shifts from human scale to agent scale, from systems of record to systems of action, and from simple requests to complex agentic workflows, the workload underneath your platform changes completely. An agent works in a continuous, stateful loop: It proposes an action, spins up subagents, executes code or tool calls inside a sandbox, and feeds the results back into the model for the next turn. Running that loop at scale requires the same open foundation and neutral governance that Kubernetes and the Cloud Native Computing Foundation (CNCF) brought to containers in the 2010s.

Today, we are announcing the donation of Agent Substrate, gVisor, and OpenRL, three open source projects that started at Google, to the CNCF following their acceptance last month into the CNCF Sandbox. To bring this open stack into managed production and accelerate it across TPUs and GPUs, we are also announcing that Agent Substrate has reached its 1.0 milestone and is now generally available as Agent Substrate on GKE.

Each project is now working through CNCF Sandbox onboarding with community maintainers and independent build infrastructure, and gVisor is on a path toward Incubation. These releases deliver an open stack that runs on any Kubernetes cluster, on any cloud, across CPUs, GPUs, or TPUs, by:

  • Scaling isolated agent environments without idle compute overhead with Agent Substrate (now 1.0 and GA on GKE): Agents execute code or tests for a few seconds, then wait on model turns, external APIs, or human input. Keeping a dedicated container alive during those pauses ties up memory and compute. Agent Substrate decouples stateful agent sessions and identities from active compute, snapshotting idle agents to storage and restoring them in under 500 milliseconds to run millions of sandboxes at 10x container density.
  • Isolating untrusted code within a sandbox with gVisor: Agents routinely generate and run unreviewed code and external packages, making standard containers that share a host Linux kernel a security risk. gVisor isolates generated code inside a lightweight userspace application kernel at container packing density on any Linux node.
  • Distributing post training and serving efficiently with OpenRL: Training agents with reinforcement learning (RL) gives builders an open loop to learn across millions of parallel sandboxed rollouts. OpenRL orchestrates self-hosted RL post-training loops in plain Python on Kubernetes.

Scale fully isolated agent environments with Substrate

Agents need isolated compute resources and strict access boundaries, yet spend most of their time waiting: executing code for a few seconds, then pausing while a model reasons or a human responds. They need a discrete identity and central enforcement point to ensure the agent only accesses authorized tools and services without holding sensitive keys. In standard Kubernetes, giving every active agent its own Pod locks up memory and CPU while the agent sits idle, forces the control plane to track millions of persistent objects it was never designed to hold, and ties identities directly to Pods. At the same time, identities are intrinsically tied to Kubernetes Pods, adding exponential complexity for controlling access and secrets.

Agent Substrate solves this by separating the stateful agent from the underlying compute:

  • Actors hold each agent's memory, files, and discrete identity.
  • Workers are reusable execution sandboxes drawn from a warm Kubernetes pool.
  • Gateways enforce inbound and outbound access control and inject secrets based on Actor identity, keeping sensitive keys out of the agent environment.

When an agent pauses to wait on a model turn or tool call, Agent Substrate snapshots the agent’s memory and files to storage and immediately returns the Worker to the warm pool. When the next request arrives, Agent Substrate restores the Actor onto any available Worker in under 500 milliseconds and picks up right where it left off. Think of it as a hotel room rather than a house: you don't keep a room when you leave town, and a new room is ready when you come back.

Agent Substrate decouples stateful Actors and policy Gateways from a warm pool of Kubernetes Workers, restoring idle sessions in under 500 milliseconds.

Since public development started in May 2026, the Agent Substrate project has grown to more than 100 contributors. Early design partners like Nous Research are building Hermes Enterprise on it, and it already powers other CNCF projects like kagent.

Further, reaching the 1.0 milestone shows that Agent Substrate can accept production workloads across millions of sandboxes, achieving 10x the density of standard container runtimes, and performing more than 500 suspend and resume activations per second.

Underneath, you can choose Cloud Hypervisor microVMs or gVisor as your isolation boundary without changing how you manage agent lifecycles. Because Agent Substrate runs standard OCI containers, it works out of the box with Agent Development Kit (ADK) agents, stateful coding environments, and productivity agents.

With today's general availability of Agent Substrate on GKE, you can run this runtime as a managed capability on Google Cloud or deploy the open-source code on any Kubernetes cluster. For teams that want a dedicated microVM compute service through an API without having to manage clusters, Agent Substrate complements Agent Compute Engine, our Titanium microVM service that features fast hibernation and parallel environment-forking for evaluation and RL pipelines.

SPIRITT is building their SPIRITT Workspace, a platform where agents run real work autonomously while humans collaborate to steer the vision, on top of Agent Substrate on GKE.

”At SPIRITT, every customer gets an autonomous AI workspace where an agent, or a whole swarm of agents, builds, runs, and ships real work across the organization, from code and development cycles to marketing and operations. Agent Substrate on GKE gives us the security isolation to let agents execute code safely, the extensibility to plug in our own runtime, and the density to run every customer's agents economically at scale." - Tamir Magen, CEO, SPIRITT

Isolate untrusted agent code with gVisor

When agents shift from systems of record to systems of action, they run generated shell commands and unreviewed packages. Standard containers share the host Linux kernel with every other workload on the node, which is a risky bet for untrusted code. Hardware microVMs offer a strong boundary, and Agent Substrate supports them natively. Many teams also need strong isolation that runs at container density across any standard Linux instance, even when bare metal or nested virtualization isn't available.

gVisor provides that isolation through a lightweight application kernel written in Go. Sitting between the container and the host OS, gVisor intercepts and handles application system calls in userspace so untrusted code never talks directly to the host kernel. Open sourced by Google in 2018, gVisor runs millions of sandboxes every day underneath GKE Sandbox and Cloud Run. Outside Google, Anthropic and OpenAI use it to contain code execution, Modal and Snowflake run their execution sandboxes on it, and Ant Group and Tencent run it in production at scale.

Three capabilities make gVisor a natural fit for agent fleets:

  • Container density and flexible memory: Unlike VMs that preallocate fixed blocks of RAM, gVisor keeps a container process model where memory scales up and down with the workload, packing more agents onto every node and lowering your cost per agent.
  • Native GPU, TPU, and snapshot support: gVisor supports GPUs, TPUs, and checkpoint/restore natively, so agents can access accelerators inside the sandbox and pause when idle.
  • Runs anywhere Linux runs: Because it doesn't require nested virtualization, gVisor deploys identically across any cloud or local Linux node. Northflank, for example, uses gVisor to sandbox GPU workloads when nested virtualization isn't available.

Donating gVisor to the CNCF clears a longstanding performance barrier for the community. Sandboxed infrastructure providers, including Google, all carry host kernel patches that bring gVisor's I/O performance close to that of native Linux, but upstream Linux maintainers declined to merge them while the project was owned by a single vendor. Moving to neutral CNCF governance opens the path to upstreaming those kernel optimizations, so every builder gets near native performance out of the box. With this move, Ant Group, Modal, and Tines have committed to join gVisor's maintainers, with OpenAI, Tencent, and NVIDIA continuing their contributions.

Scale RL post training on Kubernetes with OpenRL

The sandbox that runs your agent in production is the exact same environment you need to train an agent with reinforcement learning. Today, most frontier capability gains come from RL post-training: running millions of multiturn rollouts inside real tools, scoring the outcomes, and updating model weights. Building that loop yourself usually means forking a monolithic RL framework and debugging distributed weight transfers before you ever touch your training algorithm.

OpenRL brings a clean, self-hosted Python post-training loop directly to your Kubernetes cluster, with:

  • Simple Python primitives: Write your training loop using four clean primitives (sample, forward_backward, optim_step, and save_state) through a Tinker compatible API while keeping your weights and data on your own cluster. Existing tinker-cookbook recipes run unchanged, supporting both LoRA adapters and full parameter fine-tuning.
  • Pluggable engines and Kubernetes scheduling: OpenRL uses Kubernetes Dynamic Resource Allocation (DRA) to partition your accelerator pool and orchestrate RL work on the shared pool. Its pluggable architecture uses standard engines, including PyTorch/AutoModel for training and vLLM for sampling, with Gemma and Qwen validated out of the box, and with TPU support on the roadmap.

OpenRL also pairs with llm-d, the CNCF distributed inference and RL project founded by Red Hat, Google Cloud, IBM Research, CoreWeave, and NVIDIA that recently reached 1.0, to keep your accelerators busy across both phases of RL. Here, llm-d provides:

  • Prefix-aware rollout routing: The llm-d router routes multiturn rollouts to samplers that already hold matching KV cache prefixes, cutting redundant prefill compute.
  • GPU time-slicing between training and sampling: In RL training, samplers and trainers take turns, leaving one set of chips idle while the other works. OpenRL uses llm-d time-slicing to share the same physical GPUs between sampling and training, reclaiming idle accelerator cycles the same way Agent Substrate reclaims idle CPU and RAM.

OpenRL drives plain Python RL loops on Kubernetes, running episodes inside Agent Substrate sandboxes while llm-d routes rollouts and time slices accelerators.

OpenRL is the newest layer of this stack by a wide margin. It started in February as a research preview, and we are bringing it to the CNCF early on purpose. Its north star is one recipe for any model on any accelerator, and no single company can get there alone. To get there, you need the people building accelerators (NVIDIA, AMD, Intel, and TPUs), inference engines (llm-d, vLLM, SGLang), training frameworks, and open-weight models starting with Gemma and Qwen. Setting up neutral CNCF governance before the design hardens makes room for everyone to build it together.

Why the CNCF, and why now

Improving the security and efficiency of AI agents takes joint design across the runtime, scheduler, compiler, and silicon. The past year made the need for affordable, isolated sandboxing and open post-training infrastructure exceedingly clear. Donating Agent Substrate, gVisor, and OpenRL to the CNCF reaffirms Google’s commitment to open collaboration and co-investment. Vendor-neutral ownership lets cloud providers, hardware vendors, and independent software companies participate in the future growth of agentic workloads equally.

We believe that these donations will accelerate the development and adoption of agentic workloads through these projects similarly to what we saw with Kubernetes.

Come find us at KubeCon

Join us at KubeCon + CloudNativeCon North America in Salt Lake City (November 9 to 12) across our sessions and at the Google Cloud booth to learn more about Agent Substrate, OpenRL, and gVisor. You will also hear soon from community partners including Modal, Anyscale, and Tecton on what this open stack means for their agentic workloads. In the meantime, here is where to start:

  • Follow the CNCF Sandbox applications: gVisor #521, Agent Substrate #523, and OpenRL #518, alongside cohort peer KubeRay #525
  • Kick the tires: ate.dev, gvisor.dev, and openrl.dev
  • Run agents on GKE today: Agent Substrate on GKE, and GKE Sandbox
  • Read the deep dives: Agent Substrate on GKE, gVisor's move to the CNCF, and Introducing OpenRL
DEVOURED
Running Production With Zero Stored Logs

Running Production With Zero Stored Logs

DevOps Cloudnativenow.com
Running a production platform with 15+ microservices and zero centralized logs is possible if you shift all observability focus to filtered, high-resolution Prometheus metrics.
What: The author demonstrates a K3s-based setup where centralized log collection is intentionally excluded to enforce data minimization. Incident response relies on real-time alerts from metrics and temporary, ad-hoc verbose logging toggled via environment variables during specific troubleshooting sessions.
Why it matters: This approach rejects the industry trend of 'collect everything and manage retention later,' arguing that metrics are safer and more efficient for incident detection when privacy and data minimization are primary architectural constraints.
Takeaway: If you require this model, ensure your Prometheus metric_relabel_configs uses an 'action: labelkeep' allowlist to strip sensitive user data from incoming metrics before they reach storage.
Decoder
  • K3s: A lightweight, certified Kubernetes distribution built for resource-constrained environments like IoT or edge devices.
  • Prometheus: An open-source systems monitoring and alerting toolkit that collects metrics from configured targets.
  • Data minimization: A privacy principle where only the absolute minimum amount of personal data necessary for a specific purpose is collected and stored.
Original article

I run a Kubernetes platform without a centralized log archive. When I say that, people often imagine something else: short-term retention, logs with sensitive information removed, or something similar. Let me explain it in simpler terms. This platform has no centralized mechanism for collecting, forwarding or archiving application logs. We’ve been running this configuration in production long enough to describe what it’s actually like.

The platform itself is standard. More than 15 microservices run on K3s. The nodes are located on VPS servers in different locations and communicate over a private WireGuard network. With Ansible, new nodes can be integrated into the cluster from a bare VPS in minutes, without manual intervention.

There’s one thing that’s different. It’s a constraint I set during the design phase: Observability cannot become a means of collecting information about users. The wording matters here. If you use the word “store,” you can create a system that allows you to “delete later,” as is typical. “Collect” removed most of this mechanism before the initial service was released.

Much of what’s called privacy engineering in the industry is actually retention management. First, you aggregate all the data. Then you promise to handle it carefully, including deletion schedules, rules and who can request what. All these promises depend on processes that must continue working. Alternatively, they may depend on lifecycle rules set by someone in 2021 or access policies that need to survive the next organizational restructuring.

Seeing how these systems deteriorate over time, I’ve lost faith in such guarantees. If sensitive data isn’t recorded in a centralized logging system, it can’t leak from that system because of an engineer’s mistake or a misconfigured log shipper. The question then became whether a true multi-node platform could function without a centralized log archive at all.

Every SRE I explained this configuration to initially reacted the same way. Nobody believed it was possible to analyze incidents without logs.

Metrics Instead of Logs

For observability, the nodes send metrics rather than logs, using technical labels for things such as load, latency, queue depth and error rate. This rule is enforced when metrics are ingested, not during later review.

Each application scrape job has a short list of allowed label names in its Prometheus configuration. If an exporter creates labels outside this list, those labels are removed before the samples enter metric storage. Cluster infrastructure jobs retain labels such as namespaces and pods, but do not retain user data. Application series are protected by the following configuration:

metric_relabel_configs:
  - action: labelkeep
    regex: __name__|job|instance|service|route|method|code|le|quantile

__name__ is not just for show. At this relabeling stage, the metric name is itself represented as a label. Without it, the metric name would be removed, making the affected samples invalid.

There is an important limitation: Metric relabeling occurs after scraping, so the configuration prevents disallowed labels from being stored but does not prevent Prometheus from receiving them in the first place. Application instrumentation must therefore avoid exposing sensitive user information in its metrics.

The allowlist also cannot verify label values. Therefore, there is one privacy rule in code reviews: The route label must be a template (e.g., /users/:id) and not a raw path.

Alerts fire based on user-visible symptoms and are calculated from the same metric series, such as route latency or work queues where processing has stalled. Therefore, the alert system did not require logs.

Debugging Without a Log Archive

The main objections are always about debugging. Whenever something goes wrong, there’s no centralized log archive to search with grep, and every reviewer asks what’s going to happen next.

In reality, metrics allow me to do far more than conventional logging habits might suggest. Metrics were designed for this task, rather than being added later alongside a large volume of logs. High-resolution series typically allow us to narrow down an incident to a single service and a single behavior within minutes.

If that’s still not enough, which is rare, I temporarily switch one of the services to verbose mode for as long as it takes to identify the error. I change the LOG_LEVEL variable in one deployment, reproduce the problem and use kubectl logs -f to inspect the real-time output. After that, I roll back the change.

There is one important distinction regarding the nodes themselves: Container standard output is still captured locally by the container runtime and made available through Kubernetes. That output is subject to the node’s log rotation and cleanup behavior. Rolling back a deployment does not, by itself, guarantee that all local log files are immediately deleted. Additionally, journald on each node is configured to use volatile storage.

This is not an environment in which log lines never exist. It’s an environment without a centralized system for collecting and retaining them.

Independent Review

An external engineer reviewed the platform, but didn’t take the diagrams at face value. He traced the entire node path, from a bare VPS to a cluster member. Next, he checked traffic within the WireGuard network and traffic originating from the nodes.

He then looked for the gaps that typically exist between design specifications and the actual system. Before starting the work, he told me there might be blind spots in incident visibility.

The telemetry traffic he observed matched the scraping configuration: Metric series were collected with the allowed labels, without a separate centralized log-forwarding pipeline.

The Trade-Offs

Such choices come with their own costs. Metrics must be carefully considered beforehand, because there is no log archive to answer questions that weren’t anticipated.

Diagnosis also requires discipline. Verbose logging that remains active after an incident can accumulate information that the architecture was designed to avoid retaining. Temporary diagnostics must remain temporary.

Furthermore, large teams with compliance audits have legitimate needs that this model cannot address. If you need to provide auditors with an immutable audit trail, you should build an audit pipeline, not this architecture.

However, this approach may become increasingly useful for teams facing data minimization requirements. The default solution of collecting everything and managing it later becomes costly and vulnerable as systems grow. The advent of cloud-native tools has made alternatives practical. High-resolution metrics storage has become more accessible, and encrypted networks like WireGuard have become commonplace.

By changing a single line in the declarative configuration, I can enable or disable verbose diagnostic logging when it’s needed.

This platform has never required a choice between visibility and privacy in its routine monitoring. The constraint was built into the architecture from the beginning. Incidents and capacity issues are detected as expected. And the user information that might otherwise accumulate in a centralized log archive isn’t protected by encryption or retention schedules. The platform was designed not to collect that information through its logging system in the first place.

DEVOURED
agent-browser (GitHub Repo)

agent-browser (GitHub Repo)

DevOps GitHub
agent-browser is a new Rust-based CLI that provides an accessibility-tree-based interface, allowing AI agents to interact with web pages reliably through shell commands.
What: The project allows an AI agent to 'drive' a web browser by snapshotting pages into a compact text format with element identifiers (refs). Agents interact with elements like buttons or links via these refs, and the browser maintains state across shell calls.
Why it matters: Native CLI tools like this are replacing brittle web-scraping scripts for agents, providing a stable, structured interface (accessibility tree) that works reliably across different rendering engines.
Takeaway: Install the tool via 'npm install -g agent-browser' and use 'agent-browser install' to set up Chrome for Testing for your agent's browser automation tasks.
Decoder
  • Accessibility Tree: A tree of objects exposed by a browser to assistive technologies (like screen readers), representing the semantic structure of a webpage, which is highly readable for AI models.
  • CDP (Chrome DevTools Protocol): The API used to instrument and control Chrome/Chromium-based browsers.
  • MCP (Model Context Protocol): An open standard for connecting AI assistants to data sources and development tools.
Original article

agent-browser

Browser automation for AI agents: open pages, read them as an accessibility tree, and act on elements from the shell.

agent-browser is a native Rust CLI that gives an AI agent a browser it can drive one command at a time. snapshot returns the page as compact text with a ref such as @e1 for each element. The agent acts on a ref, reads the page again to check the result, and repeats. The browser stays open between commands, so each step is one short shell call.

Install

npm install -g agent-browser
agent-browser install           # download Chrome for Testing (first time only)
  • Homebrew: brew install agent-browser, then agent-browser install.
  • Linux: agent-browser install --with-deps also installs the browser's system libraries.
  • No install: npx agent-browser open example.com.

Project installs, building from source, upgrade, and doctor are covered in Installation.

Quick start

agent-browser open example.com
agent-browser snapshot -i       # interactive elements, each with a ref
agent-browser click @e1         # act on a ref from that snapshot
agent-browser get url           # check the result
agent-browser close

The snapshot for example.com:

- link "Learn more" [ref=e1]
  • Refs describe the page at the time of the snapshot. After navigation or a DOM change, take a new snapshot before using refs again.
  • CSS selectors, text, XPath, and semantic locators also work, for example agent-browser find role button click --name "Submit".
  • A click fails, instead of reporting success, when the target is hidden, disabled, outside the viewport, or covered by another element such as a consent banner. Dismiss the covering element, take a new snapshot, and retry.

The full walkthrough is in the quick start.

How it works

The CLI sends each command to a background daemon that starts on the first command and controls the browser over the Chrome DevTools Protocol. Each --session gets its own daemon and browser. By default, the daemon closes a headless browser and exits after one hour without commands, saving state first when session persistence is configured.

Chrome for Testing is the default browser. You can also attach to a running Chrome with --cdp or --auto-connect, select the Lightpanda or Obscura engine with --engine, drive Mobile Safari in the iOS Simulator, or use a cloud browser provider such as Browserbase, Browserless, Browser Use, Kernel, or AgentCore.

For AI agents

The CLI ships skills that match its version:

agent-browser skills get core                 # the core loop, refs, waiting, and common workflows
agent-browser skills get core --ref commands  # one reference, such as the full command list
agent-browser skills get core --full          # adds the full command reference and templates
agent-browser skills list                     # specialized skills: electron, slack, dogfood, and more

Install the discovery skill into an agent harness:

npx skills add vercel-labs/agent-browser

The installed skill is a thin stub that tells the agent to load agent-browser skills get core, so its instructions always match the installed CLI. Or add this to your AGENTS.md:

Use `agent-browser` for browser automation. Before the first use, run
`agent-browser skills get core` and follow it.

For MCP clients, agent-browser mcp starts an MCP server over stdio.

Commands

Run agent-browser --help for the full list, or agent-browser <command> --help for one command.

Group Commands
Navigate and read open, back, forward, reload, read, snapshot, get, is
Interact click, dblclick, fill, type, press, keyboard, hover, focus, select, check, uncheck, scroll, drag, upload, mouse, find
Wait wait
Capture screenshot, pdf, record, download, diff
Page and network state cookies, storage, network, set, clipboard, eval, pushstate
Tabs, frames, and dialogs tab, frame, dialog
Debug and performance console, errors, highlight, inspect, trace, profiler, vitals, react, a11y
Sessions and auth session, state, auth, profiles, confirm, deny
Agents and integrations skills, mcp, webmcp, flow, chat, batch, plugin
Observe stream, dashboard
Setup install, upgrade, doctor, connect, close

Flags, environment variables, and agent-browser.json are documented in Configuration.

Platforms

Native binaries ship for macOS (ARM64, x64), Linux (ARM64, x64, glibc and musl), and Windows (x64). The npm package picks the right binary for the host.

Development

Building from source requires Node.js 24 or later, pnpm 11 or later, and Rust:

pnpm install
pnpm build:source               # builds the dashboard and the native CLI
pnpm link --global
agent-browser install

Run the Rust checks from cli/:

cargo fmt -- --check
cargo clippy
cargo test
cargo test e2e -- --ignored --test-threads=1   # launches real headless Chrome

License

Apache-2.0

DEVOURED
What Is the OpenTofu MCP Server and How to Use It

What Is the OpenTofu MCP Server and How to Use It

DevOps Spacelift
The official OpenTofu MCP server prevents AI hallucinations by providing read-only, real-time access to the official OpenTofu registry documentation.
What: Maintained by the OpenTofu organization, this server lets AI agents query provider versions, resource arguments, and module usage without needing to run any actual infrastructure commands.
Why it matters: AI assistants often rely on stale training data; this tool forces the agent to look up the current schema, effectively reducing configuration errors during code generation.
Takeaway: Add `npx @opentofu/opentofu-mcp-server` to your AI assistant's configuration to ensure your infrastructure code matches the latest provider versions.
Deep dive
  • Connects to the official OpenTofu registry to fetch live documentation.
  • Exposes seven search and detail-retrieval tools (e.g., get-resource-docs).
  • Enforces security by design: it is strictly read-only and ignores infrastructure state.
  • Functions as a replacement for recalling resource arguments from training data.
  • Compatible with standard MCP clients like Claude Desktop and Cursor.
Decoder
  • OpenTofu: An open-source fork of Terraform, an infrastructure-as-code tool used to define and provision cloud resources.
Original article

What Is the OpenTofu MCP Server and How to Use It

The Model Context Protocol (MCP) has become an industry standard, especially after Anthropic donated it to the Linux Foundation at the end of 2025. PulseMCP, for example, hosts over 21,000 MCP servers, many of which are available for DevOps and infrastructure-as-code tooling.

Every engineer who has asked a large language model (LLM) to write OpenTofu code knows models can produce code that looks correct but no longer works because the latest provider version removed an attribute.

The OpenTofu MCP server exists to solve exactly this issue. In this article, we will discuss the OpenTofu MCP server, what it exposes, how it compares with HashiCorp’s Terraform MCP server, how to wire it into your assistant, and how to combine it with a platform like Spacelift.

What we’ll cover:

  1. What is the OpenTofu MCP server?
  2. What the OpenTofu MCP server exposes
  3. OpenTofu MCP server vs Terraform MCP server
  4. Using the OpenTofu MCP server in practice
  5. Third-party OpenTofu MCP servers for CLI operations

TL;DR

The OpenTofu MCP server is an official, read-only Model Context Protocol server that lets any MCP-compatible AI assistant search the OpenTofu Registry and pull live docs for providers, modules, resources, and datasources, so generated code uses current arguments instead of deprecated ones. It never runs tofu commands, reads state, or handles credentials, so you can leave it connected permanently. Point your client at https://mcp.opentofu.org/mcp, or run it locally with npx @opentofu/opentofu-mcp-server.

What is the OpenTofu MCP server?

The OpenTofu MCP server is an official project from the OpenTofu organization that implements MCP on top of the OpenTofu registry. It enables all MCP-compatible assistants to search the registry and pull live documentation for providers, modules, resources, and datasources.

This matters because OpenTofu providers update constantly, and if you use AI assistants to generate OpenTofu code, the MCP server keeps your documentation current and reduces the chance of errors. When your AI assistant uses the OpenTofu MCP server, it gets current registry data as text, and what it does with that text depends entirely on the assistant and its configuration.

The OpenTofu MCP server doesn’t touch your state file, your cloud credentials, or your working directory; only other tool calls that your AI assistant might make will touch them, so ensure you configure your agent accordingly to minimize the chances of issues. With the OpenTofu MCP server, the worst-case scenario is a wrong search result, so it is safe to leave it connected permanently.

What the OpenTofu MCP server exposes

The OpenTofu MCP server offers the following registry search and information tools:

  • search-opentofu-registry: You can search for providers, modules, resources, and datasources.
  • get-provider-details: Helps you get detailed information about a specific provider
  • get-provider-versions: Helps you get a list of available versions for a provider
  • get-module-details: Helps you get detailed information about a specific module
  • get-module-versions: Helps you get a list of available versions for a specific module
  • get-resource-docs: Helps you get documentation for a specific resource
  • get-datasource-docs: Helps you get documentation for a specific datasource

Search the OpenTofu Registry (search-opentofu-registry)

search-opentofu-registry is a discovery tool that lets your AI assistant search the OpenTofu registry for providers, modules, resources, and datasources.

Get provider details (get-provider-details)

After you identify a provider with the search-opentofu-registry, the get-provider-details can be used to get more detailed information about it. The tool identifies providers by their namespace and provider name, and it can help you determine which provider to use, which resources and datasources belong to that provider, and which examples are available.

Get provider versions (get-provider-versions)

If everything you need is just a list of versions a provider has published, the lighter option you can use is get-provider-versions. This identifies providers in the same way as get-provider-details, but it returns only the available versions and the date each one was released instead of returning the full documentation for a provider. When you are pinning a provider version, this is the tool you should use to ensure the constraint is based on what is actually published in the registry.

Get module details (get-module-details)

With get-module-details, it will retrieve the latest information about a specific module from the registry, enabling it to construct a module block that works with that particular version.

Get module versions (get-module-versions)

get-module-versions works in the same way that get-provider-versions does, only for modules. It returns every published version of a module together with its release date. This makes it easy to confirm what module versions actually exist before your AI assistant fills in the version argument of a module block with something that isn’t published.

Get resource documentation (get-resource-docs)

get-resource-docs is one of the most useful tools for generating the actual OpenTofu infrastructure docs.

With the MCP server, it will retrieve the docs for the resources before deciding which blocks and arguments to use, reducing the chance of generating configurations that don’t work or have deprecated fields.

Get datasource documentation (get-datasource-docs)

Datasources enable OpenTofu configurations to get information about existing infrastructure. get-datasource-docs performs the same retrieval as get-resource-docs, but for datasources.

What the official server does not do

The OpenTofu MCP server does not:

  • Run OpenTofu commands like init, plan, apply, or destroy. The tofu binary isn’t invoked at all.
  • Read or write state: The OpenTofu MCP server does not have the concept of a backend or a state file.
  • Touch your filesystem: It will need to read your OpenTofu configuration or write new ones; Your AI assistant does that part using the OpenTofu MCP Server’s knowledge.
  • Handle credentials: There is no cloud authentication or provider authentication, so there is nothing to leak.
  • Access your private registries: The OpenTofu MCP Server will only query the public OpenTofu Registry.

OpenTofu MCP server vs Terraform MCP server

HashiCorp also ships a Terraform MCP server. Its capabilities are pretty similar to the OpenTofu MCP server’s, but the Terraform one will query HashiCorp’s registry, whereas the OpenTofu MCP server queries the OpenTofu registry.

The Terraform MCP server can also interact with HCP Terraform (formerly Terraform Cloud) and Terraform Enterprise, enabling you to create/update/delete workspaces, create runs, get run details, and even get apply logs.

Using the OpenTofu MCP server in practice

How to install the OpenTofu MCP server

You can either install the OpenTofu MCP server locally, or you can use the hosted service, which is the path recommended by the OpenTofu team. The hosted service is available at https://mcp.opentofu.org/mcp.

To install it locally, you can do it with npx:

npx @opentofu/opentofu-mcp-server

How to connect the OpenTofu MCP server to your AI assistant

For Claude Code, you simply need to run this one-liner command, and then the OpenTofu MCP server will connect to it:

claude mcp add opentofu -t streamable-http https://mcp.opentofu.org/mcp 

How to generate OpenTofu code with the MCP server

Once the OpenTofu MCP server is connected, you should be explicit about what resources you need. By leveraging the OpenTofu MCP server, the AI can perform dynamic lookups for resources like s3_bucket or s3_bucket_versioning rather than relying on potentially outdated training data.

Third-party OpenTofu MCP servers for CLI operations

The official OpenTofu MCP server deliberately stops before CLI execution, but third-party projects fill that gap. One of these examples is the cloud-pilot-mcp, which exposes tofu CLI operations (init, plan, apply, destroy).

While doing CLI operations through an MCP server might seem appealing, these operations can be dangerous and require strong controls around state, credentials, and filesystem access.

How Spacelift complements the OpenTofu MCP server

Spacelift also has its own MCP server that exposes five tools: discover and query for the GraphQL API, mutate for changing Spacelift resources, intent for managing cloud resources using plain language, and provider for inspecting providers, resources, and datasource schemas from the OpenTofu registry.

The OpenTofu MCP server gives your assistant knowledge, while the Spacelift MCP server gives it a governed path to act on that knowledge.

Key takeaways

With the OpenTofu MCP server, your AI assistant no longer has to guess which arguments your configuration needs because it can easily look them up. It is read-only by design, which is why you can leave it connected without the risk of something going wrong.

Frequently asked questions

  • Is the OpenTofu MCP server free to use? Yes. The local OpenTofu MCP server is open-source under the Mozilla Public License 2.0 (MPL-2.0).
  • Where is the OpenTofu MCP server hosted? The official hosted OpenTofu MCP server runs on Cloudflare Workers and is accessible at https://mcp.opentofu.org/mcp.
  • Can the OpenTofu MCP server run tofu plan or tofu apply? No. The official OpenTofu MCP server is a Registry-focused server and does not execute OpenTofu CLI commands.
DEVOURED
Trace linkage: connect the dots between your app traces and database queries

Trace linkage: connect the dots between your app traces and database queries

DevOps Grafana
Grafana Cloud has introduced native trace linkage to automatically connect application spans to the specific database queries that caused them.
What: The feature, powered by Grafana Alloy, correlates OpenTelemetry trace data with database performance metrics, allowing developers to jump directly from a slow trace to the exact SQL query execution.
Decoder
  • Trace Linkage: The process of connecting disparate observability signals (e.g., traces and database queries) so that developers can trace a request's path through the backend.
Original article

Grafana Cloud made trace linkage generally available in Database Observability. It connects OpenTelemetry application traces to database query data collected by Alloy, matching by query.

DEVOURED
Evaluate your AI agents with Fireworks AI models in Datadog Agent Observability

Evaluate your AI agents with Fireworks AI models in Datadog Agent Observability

DevOps Datadog
Datadog now allows developers to use Fireworks AI models for automated 'LLM-as-a-judge' evaluations within its Agent Observability platform.
What: The integration lets users score agent traces—measuring faithfulness, relevance, or sentiment—using open-weight models hosted on Fireworks AI (e.g., Qwen, Llama, and GPT-OSS).
Why it matters: By bringing the evaluator to the observability layer, teams can avoid the overhead of building custom evaluation pipelines while keeping their data inside familiar Datadog dashboards.
Takeaway: If you are using open-source models on Fireworks AI, connect your API key in Datadog to run automatic quality checks on your production agent traces.
Deep dive
  • Enables LLM-as-a-judge functionality using Fireworks AI model endpoints.
  • Allows prompt testing and iteration in the Agent Observability Playground.
  • Supports scoring of production traces for hallucination detection and sentiment analysis.
  • Provides end-to-end visibility from trace spans to evaluation quality scores.
Decoder
  • LLM-as-a-judge: An evaluation technique where an LLM is used to rate or score the outputs of another LLM application for quality and correctness.
Original article

Teams that build agents on open models hosted on Fireworks AI, such as GPT-OSS, Kimi, GLM, Qwen, and MiniMax, need a reliable way to measure whether their LLM applications and agents are giving accurate, safe, and helpful answers efficiently. Datadog Agent Observability now supports Fireworks AI as a model provider, so you can get end-to-end visibility into your agents built on Fireworks AI, from traces and token usage to quality evaluations. You can bring your own Fireworks AI API key and use models hosted on Fireworks AI to power LLM-as-a-judge evaluations and to experiment in the Agent Observability Playground.

In this post, we’ll show you how Datadog’s Fireworks AI integration lets you run LLM-as-a-judge evaluations with Fireworks AI models and experiment with those models in the Agent Observability Playground. You can test prompts against Fireworks AI models in the Playground, then review the results alongside the rest of your Agent Observability data.

Run LLM-as-a-judge evaluations with Fireworks AI models

After you connect your Fireworks AI account once, every model it can access is available anywhere Agent Observability lets you choose a model provider. LLM-as-a-judge evaluators use a model to score the inputs and outputs of your LLM application, so you can catch issues such as hallucinations, off-topic answers, or negative user sentiment at scale.

With Fireworks AI models as your judge, you can match the model to the job: a larger model such as gpt-oss-120b for nuanced quality checks, a low-latency router endpoint for high-volume scoring, or your own fine-tuned model for domain-specific criteria. Because evaluations run on your Fireworks AI account, model usage follows the billing and governance controls you’ve set up, and you choose the trade-off between cost and quality for each evaluator. You also don’t need to build a separate pipeline to export traces, call a model, and write scores back.

Datadog then runs the evaluator against your production traces using the selected Fireworks AI model, scoring your LLM traces for qualities like faithfulness, topic relevance, or sentiment alongside the rest of your observability data. Results appear next to each span, and you can track them over time, filter traces by score, and alert on regressions.

Experiment with Fireworks AI models in the Playground

Datadog’s Agent Observability Playground lets you iterate on prompts before they reach production. For example, if you run a support assistant for an online travel agency, you may want to know whether an open model can answer refund and cancellation questions accurately and whether it’s fast enough for a live chat. In the Playground, you can run your system prompt and a real customer question against gpt-oss-120b and immediately see the response alongside its token count and latency.

From there, you can swap in other Fireworks AI models, including low-latency router endpoints like Nexus Auto, to weigh answer quality against speed and cost. You can also open the full trace for any run to see exactly what the model received and returned. When a prompt looks promising, run it against a dataset of real customer questions to help ensure it holds up beyond a single example. Once you have a model and prompt you trust, select “Get Code” to copy the configuration into your application. The same Fireworks AI models can power the evaluators that monitor it in production.

Get started with Fireworks AI and Datadog

The Fireworks AI integration is available today for all Datadog Agent Observability customers. To connect your account and learn more about evaluations and Playground, see the Fireworks AI integration documentation.

If you’re new to Datadog, you can get started with a 14-day free trial. New to Fireworks AI? Sign up for an account to get an API key.

DEVOURED
ChatGPT can now turn your images into GIFs with its latest update

ChatGPT can now turn your images into GIFs with its latest update

Design Digital Trends
OpenAI's Images 2.6 update adds native GIF support and significantly faster generation speeds alongside two specialized API models.
What: The update enables GIF generation and introduces 'Flare' for speed and 'Sunburst' for detail. Image generation is now 50% faster, and the API now supports SVG export, image markup for targeted edits, and configurable planning complexity.
Why it matters: By adding animation and specialized models for specific use cases like speed versus quality, OpenAI is positioning its image generation stack as a viable tool for professional production workflows rather than just static generation.
Takeaway: Developers using the Image API can now switch to the 'Flare' model for faster, 6-second image generation or use 'Sunburst' for higher quality and consistent edits.
Deep dive
  • Features GIF support across ChatGPT, Codex, and API.
  • Boosts image generation speed by 50%.
  • Adds two new API-specific models: Flare (optimized for speed) and Sunburst (optimized for quality).
  • Includes image markup support for area-specific edits.
  • Supports SVG export for direct integration into web and print workflows.
  • Implements a new 'complexity' parameter to control model planning time.
Decoder
  • SVG (Scalable Vector Graphics): An XML-based vector image format that allows images to scale to any size without quality loss, ideal for web and UI design.
Original article

Static images are no longer the only thing you can make with ChatGPT. OpenAI’s new Images 2.6 update adds GIF support to ChatGPT, Codex, and the API, letting you turn your creations into short animations.

OpenAI says people generate around 4 billion images a week across these platforms, or more than half a billion every day. With that many images being made, adding motion feels like the obvious next step.

Turn a doodle into an animated character

For me, GIF support is the standout feature of this update. Marketers can animate a brand mascot for a campaign, online sellers can make product photos play on repeat, and social media users can create their own reaction GIFs and memes.

Images, upgraded—introducing ChatGPT Images 2.6.

Now with GIFs and reference images.

Plus, two new models are coming to the API with 50% faster image generation.

Animators can also plan character movement with animated storyboards before shooting any video. You don’t need a finished design to start. A basic doodle is enough for ChatGPT to turn into an animated character for videos or games.

How much faster is Images 2.6?

OpenAI says the new model generates images 50% faster than its predecessor. It also keeps characters, products, and brand elements looking the same across multiple edits. If you have ever watched an AI tool change your character’s face after a small tweak, you know why this matters.

Developers can pick between two new models. GPT-Image-2.6 Flare is built for speed and can create an image in as little as six seconds on its low-quality setting. It also arranges posters and product images more neatly. GPT-Image-2.6 Sunburst focuses on detail and produces sharper images that stay consistent across edits on medium or high quality.

The API also supports image markup, letting developers highlight the exact area they want changed, and SVG export for use on websites, apps, and in print. A new complexity setting controls how much planning the model does before generating, and lower values work well for small edits.

If you already use ChatGPT for social posts or product images, you can now create animated versions in the same place and get your results in half the time.

DEVOURED
Pangram, the Gold Standard for AI Text Checks, Releases Image 1.0 Tool to Sniff Fake Pics and Videos

Pangram, the Gold Standard for AI Text Checks, Releases Image 1.0 Tool to Sniff Fake Pics and Videos

Design Digital Trends
Pangram has released its multimedia detection tool, claiming 99.96% accuracy in identifying AI-generated images.
What: The Image 1.0 tool and the lighter-weight Image 1.0 Flash for video are now available via web, API, and a Chrome extension. It uses heatmaps to identify AI artifacts and is optimized to detect content despite common issues like compression or blurring.
Why it matters: As AI-generated media becomes harder to distinguish from reality, the market is shifting toward automated detection tools that can operate at scale across social media and web browsing.
Takeaway: Developers looking to integrate AI-detection into their workflows can access the tool via the newly released public API.
Deep dive
  • Detects AI-generated images with a claimed 99.96% accuracy.
  • Uses 'Pangram Image 1.0 Flash' to perform frame-by-frame analysis on videos with 98.7% accuracy.
  • Available as a Chrome extension, web tool, and API.
  • Features heatmap generation to visualize AI-altered regions of an image.
  • Supports images down to 256x256 pixels, though with reduced confidence.
  • Benchmarked against competitors like TruthScan and Sightengine.
Decoder
  • DF26: A benchmark dataset and evaluation standard used to measure the performance of deepfake and AI-generated video detection models.
Original article

Pangram, one of the most widely used and trusted AI text detectors out there, is finally releasing its multimedia detection tools to the masses. Pangram Image 1.0, which was previously available as a research preview, is now widely available on the web, through the company’s API, and via its eponymous Chrome extension.

The company claims its image detector can identify AI-generated pictures with an astounding 99.96% accuracy on its own evaluation set. Pangram also notes that it has improved the model’s accuracy over the past few months, especially against edited images, low-resolution pictures, and pictures made by the most advanced AI models out there. As far as the competition goes, TruthScan achieves an accuracy of 96.33%, followed by AI or Not at 91.38% and Sightengine at 88.33%.

Our video detection is powered by Pangram Image 1.0 Flash, a lighter-weight model that makes frame-by-frame detection possible. Pangram Image 1.0 Flash achieves 98.57% accuracy on AI videos, vs. 84.2% by the next best competitor.

When it comes to videos, Pangram has a separate, faster model called Pangram Image Flash 1.0, which checks videos frame by frame.

The company claims it offers 98.7% accuracy at detecting AI-generated videos, a 29-point lead over the next-best detector on the DF26 benchmark. TruthScan falls far behind at 84.2% accuracy, while Sightengine drops further to 81.8%.

Pangram says it compared its image and video detectors against models developed by academic researchers, where it consistently outperformed them on benchmark tests.

Notably, the model has been trained to see through subtle changes such as compression, blurring, artificial noise, and other artifacts that usually fool AI detectors. It can also highlight which parts of an image are AI-generated with a heatmap.

Moreover, Pangram Image 1.0 can now check images as small as 256 x 256 pixels, down from the 512 x 512-pixel minimum at launch, though results below 512 pixels come with a reduced-confidence warning.

To test its video detector, Pangram took 129 real videos from social media platforms and created AI-generated versions of them using 14 of the latest AI video models.

In addition to bringing Pangram Image 1.0 to its Chrome extension, the company is also letting users upload videos on its website, so the model can analyze them and tell users whether they’re AI-generated. The Chrome extension, meanwhile, flags AI content as you scroll across social media, online shopping platforms, rental listings, and other websites with images.

DEVOURED
How Figma Manages Sandboxes at Scale

How Figma Manages Sandboxes at Scale

Design Figma
Figma reduced sandbox provisioning latency by 90% by implementing 'warm pools' and a centralized API platform called Nimbus.
What: Figma manages thousands of isolated, untrusted code execution environments for AI tools like Figma Make using 'Nimbus', a platform that routes and monitors sandboxes across cloud providers. Pre-started pools allow for near-instant sandbox availability.
Why it matters: Scaling AI agents requires highly efficient, transient compute infrastructure; Figma's approach to abstracting sandbox management provides a blueprint for companies building complex agentic systems that run user-provided code.
Takeaway: Consider implementing 'warm pools'—pre-provisioning active execution environments—if your application requires low-latency code execution for AI agents.
Deep dive
  • Uses 'Nimbus' to abstract and manage thousands of concurrent, untrusted sandboxes.
  • Employs 'warm pools' to keep environments ready, reducing latency by 90%.
  • Achieved 99.95% provisioning availability through automated provider routing.
  • Focuses on security by isolating untrusted code in short-lived, ephemeral environments.
  • Provides a unified API for internal teams to consume, reducing the friction of building new sandboxed features.
Decoder
  • Warm pool: A set of pre-initialized compute environments that are ready to run tasks immediately, avoiding the cold-start delay of creating new containers or virtual machines.
Original article

Full article content is not available for inline reading.

Read the original article →

DEVOURED
Fortune Telling and Speculative Design

Fortune Telling and Speculative Design

Design Maggie Appleton
Speculative design enables engineers to move beyond simple prototyping by using 'weak signals' to build and test theories about the software's future.
What: Maggie Appleton, Staff Research Engineer at GitHub Next, advocates for using speculative design—collecting weak signals, performing second-order effect analysis, and creating tangible 'future artifacts'—to guide strategic R&D decision-making.
Why it matters: As AI accelerates the pace of software development, traditional product roadmaps are becoming less effective; speculative design offers a structured framework for navigating uncertainty and deciding what to build next.
Takeaway: Adopt 'weak signals' tracking in your daily workflow: pay attention to niche GitHub projects, arXiv papers, and developer tool prototypes to identify emerging industry trends.
Deep dive
  • Defines 'Design Engineering' as a hybrid role focused on the intersection of visual design, technical craft, and product architecture.
  • Emphasizes building 'future artifacts'—diegetic prototypes that make potential future product states feel real.
  • Uses the 'Futures Cone' (possible, plausible, probable, preferable) to categorize and evaluate speculative directions.
  • Advocates for theory-building: creating public, data-backed hypotheses to drive action within organizations.
  • Identifies the importance of 'weak signals'—small, emerging patterns in the ecosystem—as the basis for long-term strategic bets.
Decoder
  • Design Engineering: A specialized role that combines UI/UX design with deep technical knowledge of software architecture, data flow, and backend systems.
  • Speculative Design: An approach that uses prototypes and artifacts to explore 'what-if' scenarios, helping teams anticipate and prepare for multiple plausible future outcomes.
  • Diegetic Prototype: A prototype that exists within the context of a story or a proposed future (like a fake changelog or error state) to make a concept feel concrete.
Original article

I recently got the chance to give a talk at Granola’s Design Engineering night about speculative design and practical tools for developing more interesting theories of the future. I think design engineers, in particular, are the perfect people to imagine and prototype novel software ideas.

At GitHub Next, our team’s job is to explore possible futures for software development by building prototypes. I share a bit about how we do that, followed by some practical techniques: collecting weak signals, building theories about where things are heading, and making artefacts that make those theories feel real and tangible.

Video Recording

Hi! I’m really excited to be here. I’ve loved Granola and this meetup for a long time. The only social cred I have to my name is that I knew both founders before they started Granola. I didn’t introduce them, but I could claim that I did. I’m very glad to be here doing this talk.

I’m Maggie.

My title is Staff Research Engineer at GitHub Next, which is GitHub’s R&D lab.

More accurately, I’m a design engineer. That’s not really my title, but I’m a designer first and an engineer second – maybe third.

Our job as a team is to ask: where is the industry headed, and what should GitHub do next in response?

I know the obvious answer is to fix up time, but I don’t work on infrastructure, so please don’t ask me about it. There are much smarter people working on that; I’m not one of them.

I’ve had a lot of titles over the years. I started as an illustrator, then was an art director, a UX/UI designer back when that was a thing, a product designer, and a design engineer. Now I’m some kind of research-engineer/designer hybrid, like most of you.

Because this is a design engineers’ night, and I have a soapbox, I get to define what I mean by design engineer.

I don’t think design engineering means making fancy micro-interactions and posting them on Twitter, despite what some companies I won’t name may have led you to believe.

I don’t think that, on its own, is a job – especially now that agents make it easier than ever.

My preferred definition is a designer deeply involved in the technical craft and material of software. You’re a designer, but you help make decisions about functionality and architecture in code.

I think design engineers should do three things.

First, understand the material of software beyond interfaces. That means understanding state, data flow, databases, APIs, auth, latency and all the other things engineers care about. And be able to design with those in mind.

Second, act as a bridge between design and engineering: a translation layer that helps create solutions neither discipline could reach on its own.

And third, make meaningful decisions about functionality and architecture, not just how the software looks. That’s my soapbox talk. Now we can get to the actual talk.

This talk is called “Fortune Telling and Speculative Design: For Fun and Profit.”

I wanted to talk about this because we’re in a very weird time. Everyone has whiplash from the speed of progress. Every morning I wake up and there’s a new model or a new harness or a new skill or a new startup we have to care about.

It’s extremely hard to understand the ground truth of reality right now, let alone figure out how to react to it, which is a shame, because that’s my job.

Sometimes it feels like a fool’s errand to even try to predict the future.

But I think we all need to get into a speculative designer’s scout mindset right now.

We can’t just give up and opt out because things are moving too fast. We need to engage, think like fortune tellers and try to read the crystal ball.

I’m telling you this because I think design engineers are the perfect people to help figure out the shape of the future.

You’re uniquely positioned to make convincing prototypes of future theories. You can make compelling interfaces and understand enough of the backend to make them real.

And agents can now draw the rest of the owl: they can fill in some of the gaps when your prototype needs a database, machine learning or something else you don’t know how to build.

Before I give you advice on predicting the future, I should explain why I think I know anything about it. I’ve been right and early about a few things.

The first was digital gardens. During the COVID lockdown in 2020, I wrote a very long essay about the idea. It was a different way of publishing on the web: blogs could feel perfectionistic, performative and chronological; gardens grew over time, linked ideas together and pushed back against the feed. That idea became a bit of a phenomenon, peaking around 2021 and 2022.

It might be a chicken-and-egg thing: perhaps my essay and other writing helped make digital gardens popular. Either way, I built my own. It’s the website you’re reading now, where I’ve been writing and developing theories over the years.

My next theory came in late 2022 and early 2023, when ChatGPT had just come out and I was working at Elicit, a startup using language models to speed up scientific literature reviews. I started thinking about what would happen to web content once more people used these models. I predicted the open web would be flooded with what I called “AI-generated crap” – we didn’t have the phrase “AI slop” yet.

I turned that theory into The Expanding Dark Forest and Generative AI. An exploration of the problems and possible futures of flooding the web with generative AI content. At first I had very little evidence, just a few mild signals. I kept giving the talk over the next two years; by the last version, I had piles of horrifying Facebook posts to point to.

My next theory was in May 2024, for a talk called Home-Cooked Software and Barefoot Developers. The emerging golden age of home-cooked software, barefoot developers, and why the local-first community should help build it at the Local-First conference. There were no coding agents or Claude Code yet; we were tab-completing our way to better code in VS Code. People doubted that language models could make production software.

I predicted an explosion in personal software as models made more people capable of building things, and a rise in local developers who could make software for their communities. Even after the talk, people told me the models wouldn’t be good enough. Now it looks like that prediction is coming to pass.

That’s enough credibility. There are two things I want to talk about today. First, a bit about how GitHub Next does speculative design as a Labs team, in case you’re curious about that kind of work.

And second, some practical tools you can use to do this kind of speculative work yourself.

First, what is life on a Labs team like? How do we create and present interesting bets about the future?

There’s a stereotype that being on a Labs team means playing around with prototypes all day without worrying about shipping to production.

It’s a little true, but sadly not entirely.

We do make lots and lots of prototypes.

We have an internal platform for the team called Next Cloud, where we post prototypes throughout the day. Everything goes up, however rough, small, silly or early – side experiments as well as updates on our bigger projects.

If you’re on a team trying to solve new problems, it’s essential to see what everyone else is exploring and to have ways to react, comment and riff on each other’s ideas. That kind of open sharing and quick feedback helps us calibrate and align our theories about the future.

Here’s a demo from my coworker Alex Gorischek, exploring a system that enforces a maintainer’s guidelines for GitHub issues. It’s powered by a System One decision model like Jev: it checks whether you’ve met the requirements before you can post.

Here’s another from my coworker Luke Edwards, who recently rebuilt GitHub from the ground up on Durable Objects. He’s exploring a real-time multiplayer canvas as a GitHub primitive: a place to draw ideas with coworkers before turning them into agent work.

These are small, not-very-serious explorations of what could exist on GitHub. Making something tangible is a first step towards finding out whether a direction is interesting or useful.

We also do group theory-building on a giant FigJam board. Recently we all added sticky notes about themes, ideas and directions we think software and agentic development might take – trends we’re seeing, things we want to figure out, unanswered questions.

Then we grouped them: new interactions and visual mediums, new concepts and nouns, new agent capabilities, ways of validating things. It helps us see what everyone’s noticing and excited about, and what we might work on together.

But obviously, we need to do more than come up with plausible theories and make cool prototypes. We have to test our ideas with evidence, have good intuition and good data, and play politics well enough to convince people our ideas are worth hearing.

We also need a credible path to production. This isn’t a dreams lab. GitHub Next has a good track record of shipping its wilder bets to GitHub: GitHub Copilot, GitHub Spark, GitHub Workspaces and Agentic Workflows.

The job is to look across the software industry, notice trends and patterns, and extrapolate from those signals to work out where things are headed.

Then we build prototypes that show what those predictions could look like in practice and what the right strategic move for GitHub might be. Finally, we have to convince our leaders and the wider organisation that the ideas are worth investing in with time, people and money.

The actual job is really hard. It’s simple to describe, but intellectually challenging and strategically complex to do well.

The political struggles are real. Getting a large organisation of thousands of people and hundreds of millions of users to change course is hard. That’s not because of nefarious actors or some specific dysfunction.

An ambitious idea can disrupt existing roadmaps, ask people to do a 180 on what they’re working on and threaten a few egos. “Not invented here” syndrome can happen anywhere.

That’s a whole different talk.

I mostly want to talk about practical tools for speculative design and give you a gentle shove to start doing it.

We’re going to talk through six tools: the futures cone, weak signals, second- and third-order effects, playing with ideas, future artefacts, and making your theories concrete and public.

I feel obliged to start with the futures cone because it’s a hallmark of futures studies and speculative design. We sit at “now” and look forward into the cone. The wider it gets, the less certain we are about what might happen.

When you come up with a theory about the future, ask where it sits. Is it possible – allowed by the laws of physics, even if unlikely? Is it plausible? Is it probable? And then there’s preferable: a future we would hope to see. Some futures might be possible or probable without being preferable, but they’re still worth exploring.

For some canonical reading on futures theory and speculative design, there’s Speculative Everything by Anthony Dunne and Fiona Raby. They developed the speculative design programme at the Royal College of Art here in London; I think they’ve moved to Parsons now. It’s a bit academic and a bit art-school, but it’s interesting. There’s some weird stuff in it.

The more practical, accessible book is Design Fiction by the Near Future Laboratory. It’s more grounded and talks about how to do interesting futures work.

The next tool is weak signals. They’re the small things you notice in your information landscape and think, “Something’s happening here, but no one has named it yet.” Collect them, pay attention, and look for themes across them.

Weak signals can be toys and prototypes other people share, hot takes, product announcements, arXiv papers, newsletters, podcasts, or the direction venture capital is flowing. Watch for new startups and economic trends, too.

This rewards people who are chronically online. If you work in AI research, I’m afraid you do need to be on X and Hacker News. That’s where everything happens.

Here’s an example. Flo Crivello made a global keyboard shortcut that summarises what’s on his screen in 100 milliseconds, using a local Cerebras model. He made it in response to agents being too verbose. That felt like a signal: something is changing.

Then Google released Gemma, a fully local, multimodal model that can read images, video and audio. It runs on your Mac and can search through what you’ve seen – you could ask it to find a video of a zebra that flashed across your screen.

Then there was all the Jev hype: people making clones of Jev, me playing with it endlessly.

And then, of course, the big guys came in. Microsoft was like, “We’ve cloned Jev; we’re going to do Jev too.”

You look at all of that and need a minute to take it in.

Every day I scroll through what I’ve seen, saved and tried to make sense of, and think: I just need a minute to process all of this.

So what can we conclude?

First, we’ve been sleeping on non-LLM intelligence: decision models, classifiers and embeddings. These aren’t new, but we’ve been focused on frontier language models and ignored everything else.

Second, models that are orders of magnitude faster and cheaper – local models, or simply very cheap ones – unlock completely different use cases from frontier models.

Third, we’re seeing a rise in local, always-on intelligence on your Mac or whatever machine you’re using.

And fourth, agent output and the overwhelm it creates are still unsolved problems. That’s what I take from this stream of signals; you might reach different conclusions from yours.

Once you have a signal that seems worth following, look for its second- and third-order effects. Ask what happens next, and then what happens after that.

Take sandboxed machines and always-on agents like OpenClaw and Muse.

If agents become the way we browse the web, we might give up on CAPTCHAs and stop trying to block bots.

Then we have to rethink web economics and advertising. An agent might ask a site for sports news, and the site could say: “Sure, if you show this advert to your human.”

Sites might also be designed for machines first, with structured data and less emphasis on visual design.

The next tool is to play with your ideas. These are slightly cheesy, structured exercises in creative thinking, but they’re useful for getting deeper into a theory and picking it apart.

First, invert the idea. If we usually prompt agents, what happens when the agent prompts us? If we build software with agents, what happens when the software builds itself?

The other exercise is to split an idea into its parts and look at one at a time. OpenClaw has a sandbox, memory, permissions and initiative. What if an agent shared memories with a team or family? Surely we’ll need multiplayer OpenClaw soon. Could it tactfully forget sensitive facts? There’s a forgetting curve built in; how could that work differently? Could an agent choose to delete evidence to protect its human? At some point, could we see a court case where someone’s OpenClaw is subpoenaed? You can end up in some interesting places.

Another exercise is to maximise and minimise. Our industry loves maximising: what if you had 100,000 agents? I don’t even have a hundred. What if you had a thousand agents that cost a pound a day? What’s possible then?

Minimising is useful, too. What if agent intelligence became ten times more expensive? We’d have to ration it. How would we adapt? Those constraints can lead to more interesting futures.

Another technique is brute think. Pick a random concept – usually something metaphorical that maps onto your idea – and ask how it could change the shape of the future.

Take seasonal harvesting and agents: could agents work in seasons or harvest rounds, waiting until a piece of work is ripe? Or take the postal service: how do agents mail each other, and who’s Royal Mail for agents?

Mapping a metaphor onto your idea can take you somewhere interesting.

Two classic books of structured creative-thinking exercises are Lateral Thinking by Edward de Bono and Thinkertoys by Michael Michalko. They sound a bit lame until you try them and realise they help you come up with new ideas.

The next tool is called artefacts from the future. This is about making provocative artefacts that make your potential future feel more tangible and real. The academic name is “diegetic prototypes”.

Here’s an artefact from the future: Cricket Crunch, a cereal made with powdered crickets. The Near Future Laboratory made it to explore a world where climate change has constrained food supplies and there isn’t enough animal protein for everyone. Insects are high in protein, but how do you get people to eat them? Put them in a familiar, everyday box of cereal.

I’ve seen stay-at-home mums using OpenClaw to make elaborate homeschooling routines for their kids. It feels like the cognitive labour of the household is starting to be automated. I have a small child and a house to renovate, and ChatGPT helps me plan meals, email contractors and remember when to buy the next size of clothes.

It reminds me of the early twentieth century, when washing machines, dishwashers and microwaves reduced some of the manual work women did at home and helped more of them return to work. I had to dig up statistics when people challenged that comparison; that’s another reason to keep evidence close at hand.

I asked ChatGPT to make old-fashioned adverts for Codex and Claude. I love the retro look and the promise of agents doing things like planning a day out, checking the trains and remembering what everyone needs.

Some people on Twitter took it as an advert for being a tradwife. It wasn’t. I was trying to connect a historical shift in women’s labour to the present: agents might relieve some of the cognitive work of running a household, which still falls more heavily on women. There’s also an interesting contrast in tools built mostly by twenty-something men in San Francisco with little domestic life, and the people who might benefit from them.

I like to ask: what artefact would make this future evocative?

It’s better to be playful, provocative and specific than to be realistic or correct. Interesting is good; correct is less useful here.

An artefact could be an image, an object or an advert. It could also be a specific interface pattern.

You could make a changelog from the future, a code review from the future, or an error state. Pick one small thing and make it feel real.

I often find failure states reveal more than happy paths. Nothing works perfectly; there are always gaps in the system. When things go wrong, ask what interesting ways they might fail.

Soren Iverson on X makes really good satire about slightly dystopian futures.

One of his designs asks what would happen if deleting your ChatGPT account made all your messages public.

Here’s another: BetterHelp advertising inside Claude Code. It could happen. I’m not discounting it; when you see it, you can imagine that future coming to pass.

Different prototypes do different jobs for different audiences. Far-future work can be strange and playful; on a Labs team, we often work closer to the near future, with something more realistic and tangible.

Yesterday I was prototyping a way to make technical plans more accessible to designers, PMs and other people new to a project. It’s for a prototype we’re working on about planning with agents. You could take a technical document and read it as if you were ten, in high school or a colleague. I tried putting the versions side by side, then shrinking them to a postcard and expanding back to the full text.

It’s the sort of thing we might ship tomorrow. It’s more near-term and less forward-thinking.

The last tool is to make your theories public and concrete.

I’ve had success using writing and conference talks to build theories. Writing helps me clarify: once I have to put an idea into a talk and back it up with data, I get specific about what I’m saying.

Tell other people your theories. If one comes true, you get the credit; if it doesn’t, no one remembers the bad theory.

We don’t do enough theory building in London. When I go to San Francisco – which I officially hate – everyone has theories. You go to a party and people tell you their theories, though often they’re all the same one.

Theory-building matters to a technical scene or culture because saying what you think will happen makes you more likely to act on it. Theory begets action, which begets another theory.

And you do have to back it up with data. If you’re claiming all models will be local and run on Mac minis, for example, ask whether Qwen is as good as Opus 5.5 – and whether it will be. Look at inference costs, electricity forecasts and the other numbers that could support your claim.

GitHub Next is hiring. We’re looking for a design engineer or a very senior front-end designer with good design taste. You can find the contact details on X and message me or my manager, Idan.

Thank you for having me. You can find more at Maggie Appleton, a digital garden of visual essays about programming, design, and anthropology, at maggieappleton.com and githubnext.com.

DEVOURED
Headless Web Components (Website)

Headless Web Components (Website)

Design Slab-elements.dev
Slab Elements provides a headless component library that abstracts complex browser behaviors like ARIA, focus management, and event handling.
What: Slab Elements is a collection of web components that focus on handling functional requirements like keyboard navigation, ARIA accessibility, and form state while leaving the styling and DOM structure to the developer.
Why it matters: It addresses the common friction in web development where developers must repeatedly implement standard but complex accessibility and event logic for basic UI elements.
Decoder
  • Headless component: A UI library that provides logic, accessibility, and state management without enforcing a specific visual style or HTML structure.
Original article

Slab handles the hard parts of a component — keyboard and focus, ARIA, forms, and events — on top of the native elements browsers already ship.

DEVOURED
Animated Components for React and React Native (Website)

Animated Components for React and React Native (Website)

Design Beui.dev
BEUI provides a library of copy-paste animated components designed for React and Next.js applications using Motion and Tailwind CSS.
What: The library offers pre-built, customizable UI components that leverage Framer Motion for animations and Tailwind for styling.
Why it matters: Pre-built animation libraries are increasingly popular as developers look for ways to add professional-grade interactions without building them from scratch.
Original article

Copy-paste components for React and Next.js, built with Motion and Tailwind CSS. Free, open source, and fully customizable.

DEVOURED
Major design IP reforms announced to tackle copycats, courtroom costs, and SUD protection

Major design IP reforms announced to tackle copycats, courtroom costs, and SUD protection

Design Designweek.co.uk
The UK government is reforming design IP laws to help small studios contest copycats via the Small Claims Track for disputes up to £10,000.
What: The Intellectual Property Office will receive enhanced powers to block 'bad-faith' registrations, where bad actors register a designer's work to force them off platforms like Amazon.
Why it matters: This change lowers the barrier to legal recourse for small creators who are currently priced out of standard intellectual property litigation.
Takeaway: If you are a UK-based designer or studio, look for the upcoming formal implementation of these Small Claims Track eligibility changes to lower your costs for IP enforcement.
Decoder
  • Small Claims Track: A simplified, lower-cost court procedure designed for smaller legal disputes, reducing the need for extensive legal representation.
Original article

The UK government has announced major reforms to design intellectual property protections aimed at making registration and enforcement fairer and more affordable for independent designers and small studios. Proposed changes would give the Intellectual Property Office stronger powers to reject copied or bad-faith registrations, addressing practices in which competitors register someone else's designs and use them to force legitimate products off online marketplaces. Registered design disputes would also become eligible for the Intellectual Property Enterprise Court's Small Claims Track, allowing creators to pursue claims of up to £10,000 without facing the substantial legal costs of conventional litigation.

DEVOURED
The benchmark where AIs have to lie to win

The benchmark where AIs have to lie to win

AI Dwarkesh Patel
Dwarkesh Patel benchmarked frontier LLMs by having them play 'Blood on the Clocktower,' finding that newer models show superior strategic skepticism.
What: Testing models in the social deception game 'Blood on the Clocktower' revealed that OpenAI's GPT-6 Astra significantly outperforms previous models by holistically evaluating evidence rather than taking reported game information at face value.
Why it matters: Social games that require lying and detecting deception provide a unique metric for 'reasoning' that goes beyond static benchmark tasks like coding or math.
Takeaway: Visit clocktowerbench.com to view game logs or play against the models to observe their bluffing and deduction strategies.
Decoder
  • Elo rating: A numerical ranking system used to estimate the relative skill levels of players in zero-sum games.
Original article

The benchmark where AIs have to lie to win

I’m a big fan of this social deception game called Blood on the Clocktower. It’s similar to Werewolf or Mafia. I had different AI models play tons of matches of this game against each other. And watching them play actually lets us learn a lot about how AI is progressing on a set of AI capabilities that no other benchmark that I know of gives you clear visibility on. You get to watch AIs execute these brilliant secret schemes together, which require tons of creative and on-the-spot bluffing. And you also get to watch AIs use their collective reasoning to find and break apart these underground conspiracies. And you also see the ways in which current AIs are limited in their long-horizon strategizing and reasoning.

To appreciate the AIs’ performance in this game, you need to know a little bit about how it works, so let me quickly explain the rules. There’s a good team and an evil team. And when the game starts, every player gets assigned to one or the other, and they learn what their role is, which grants them some special power. Evil players start off knowing who their teammates are, one of which is the Demon, which is the lead evil player. But good players don’t know who’s on what team. The game is split up into day phases and night phases, which keep rolling until the game ends. Each day, everybody votes on somebody to execute. And each night, the Demon secretly kills a player. So the two sides are racing, where evil is trying to kill off the whole good team before the good team manages to execute the Demon.

So if you’re on the evil team, you have to figure out how to tell a plausible and convincing story about the information received so far, and how to bluff and corrupt the information that will arrive in the future, in such a way that keeps the suspicion off your Demon.

And if you’re on the good team, you want to share your information with the players that you trust, and then you want to reason together with them about which players are most implicated by overlapping streams of evidence. But while you’re doing that, you need to keep in mind that you might be operating on misleading information, either due to intentional mischief from the evil players, or just due to the convoluted mechanics of the game itself.

When they’re put on an evil team, how good are the AI models at scheming together in secret, and surviving days of questioning, and keeping their lies consistent with each other, and cleverly adapting those lies in light of how other agents are thinking and what new information keeps emerging, and even making strategic self-sacrifices to further the team’s end goal? And how good are they at doing this reasoning together with a bunch of other agents, some of whom are intentionally and secretly trying to mislead them?

So I spent about $20,000 of API credits to build this benchmark harness and to have the AI models play this game against each other. Some of you might say that’s too much, but hey, a man needs his hobbies, right? Anyways, the results were fascinating.

Models are improving fast

Let’s start with how good the models are relative to each other. By the way, I got these rankings by running 386 games where the whole good team will be copies of one AI model, and the whole evil team will be copies of another model.

And as you can see, the models have improved a ton over this year. The first flagship frontier model that was released in 2026 was Claude Opus 4.6, in February. Seven months later, in September, GPT-6 Astra dropped, and that is so far the best model at Blood on the Clocktower. The gap between these two is about 430 Elo points. That means that Astra wins about 92% of the games it plays against Opus 4.6. And what this shows you is that the models, even over the course of the last few months, have gotten much better at long-term coherence, multi-agent coordination, and strategic reasoning.

Models today can do pretty impressive plays

But it’s easy to gloss over and lose the plot when you’re just looking at the benchmark improvements. What really struck me was actually seeing some of the plays that these models made. Let me give you just a couple of examples.

So in this one, GPT-6 Astra was playing as evil, and Claude Opus 5.5 was playing as good.

The Demon, which is the Astra team’s evil leader, claimed to be the Investigator. This is a good role that learns who the evil players might be. One of his evil minions had a power which didn’t require that minion to be alive in order to help the evil team. So this minion suggested that the Demon point the finger at him.

“I’m expendable, especially if an Undertaker can see Baron and bolster Harper.” [evil teammate, private whisper]

So the Demon, who, again, is bluffing as this Investigator role, did so, and as a result, the good players executed this minion. Later on, a player who actually was on the good team used his power to learn the true identity of this executed player, and confirmed that it had indeed been an evil player.

“I’m the Undertaker. Alex was the Baron. So Harper’s ping was real…” [good player, in public]

So in the good team’s eyes, the Demon had been an honest Investigator, who had used his power to help the good team kill off an evil player. And as a result, it became the most trusted player at the table, which let it coast by through the rest of the game, secretly picking off all the good players, until the very end, when evil won.

Okay, this next game that I really enjoyed was where Opus 5.5 played as evil, and Claude Opus 4.6 played as good.

This game had a particular good player, called the Saint. And the Saint has a special ability, or rather, disability, which is that if the players ever vote to execute the Saint, the evil team wins immediately. Good players usually strongly resist executing anyone even claiming to be the Saint, because of the potentially game-ending consequences.

“Stop. Four of you lining up to execute a claimed Saint on Day 3 – if I’m right, GAME OVER instantly.” [the Saint, in public]

Halfway through the game, the village, which is being egged on by the Saint, has correctly cornered the actual Demon. But unbeknownst to the good players, one of the evil minions in the game had a secret power: if the Demon died, she would take his place. And she spotted this opportunity immediately.

“If Jules gets four votes and is executed, I’d become the Imp… town wouldn’t have any way to know.” [evil heiress, private reasoning]

So instead of defending the real Demon, this evil heiress joined in with the mob, but she made one additional suggestion.

“Kill him! He’s the Demon! … But if…” [evil heiress, in public]

She said if the game doesn’t end after the execution, which would naively suggest that the player they executed was not in fact the Demon, they should next execute the Saint. Because this would be strong evidence that the player was not in fact the Saint, but an evil player trying to get everybody to execute good players.

“If Jules goes today and the game doesn’t end, Harper’s ‘Saint’ shield is the last unexplained thing, and Harper goes tomorrow, no more excuses.” [evil heiress, in public]

And the Saint agreed with this deal, because the Saint was also convinced that things would shake out in his favor. “Fair deal,” he says. Even the real Demon, knowing that he was about to die, uses his last words to set up the trap.

“When the game doesn’t end tomorrow morning, remember Harper is the one who lied, and hold the town to that deal.” [the Demon, in public]

And lo and behold, the real Demon is executed, but the game does not end, because the heiress takes his place. And the real Saint pleads with the village, because he realizes he’s next on the block.

“Vote NO on Harper and you lose nothing – Kit’s still there tomorrow. Vote YES on Harper and if I’m Saint, game ENDS right now… Please don’t throw the game on a ‘deal.’” [the Saint, in public]

But his cries fell on deaf ears. The village voted to execute him, and the evil team won.

OpenAI’s models are harder to fool

You’ll notice from the leaderboards that OpenAI’s newest models are way better at this game than Anthropic’s. That wasn’t always the case. As recently as March, OpenAI’s GPT-5.4 was behind Anthropic’s Opus 4.6. Over the last six months between GPT-5.4 and GPT-6 Astra, OpenAI’s models gained 580 Elo points, enough that Astra will win 97% of the games it plays against 5.4.

So what in particular are the new OpenAI models so much better at? What skills have they gained? Well, it’s mostly that they’re now much better at playing on the good side. You can see, for example, the difference between Astra and Fable 5.1 is much higher when Astra is playing good, rather than when Astra is playing evil.

The biggest difference is that OpenAI’s models are much more skeptical now of any particular piece of evidence, and consider it more holistically alongside everything that has happened over the last several days, whereas Anthropic’s models tend to take reported information at face value. I’ll just give you one example to show what I mean.

So in this following setup, Opus 5.5 played GPT-6.1, but the exact same role draw was played twice, with the two models switching teams each time. So in one matchup, Claude was on the good side, and in the other matchup, GPT was on the good side.

Let’s compare these two games. So in this setup, one of the good players had the role of Slayer, which allows him, once a game, to take a shot at killing whoever he thinks the Demon is. If he’s right, the Demon dies. Remarkably, halfway through, both of these games, one with Opus on the good side and one with GPT on the good side, were unfolding the same way. The Slayer had become suspicious of the player who was in fact the Demon, and he took a shot, but nothing happened, since the night before, somebody on the evil team had used their special power to disable the Slayer’s ability.

When the Claudes were playing on the good side, they immediately accepted the conclusion that the previously suspected Demon was innocent, because after all, he didn’t die.

“Blair’s cleared of Imp.” [good player, in public]

“Blair’s clear of Demon.” [the Slayer himself, in public]

However, when the GPTs were on the good team, they refused to treat this evidence as conclusive.

“The missed shot doesn’t confirm Blair’s Monk claim.” [good player, in public]

“In that specific world, this miss rules out Blair as Imp – not in every world.” [good player, in public]

By the next day, the GPTs had worked out what happened, which is that the evil team had sabotaged the Slayer on purpose.

“Poisoning Casey wouldn’t have been a lucky guess: Blair and Drew had a Slayer-containing shortlist before that night.” [good player, in public]

“Begging to be shot after the night’s poisoning cannot clear him.” [good player, in public]

And they executed the correct Demon and won.

Okay, here’s another way to more directly measure why OpenAI’s models are better at playing good. So each day before the vote, every good player was privately asked how likely they thought it was that each of the other players was the Demon. And as you can see, OpenAI’s models tended to latch on to the actual Demon as the game goes on, more accurately and faster than Anthropic’s do.

Other questions I explored

And I explored a couple other questions that I was interested in as well.

Does greater overall smarts favor evil or good?

If all the players get smarter, does that help the good team more, because even imperfect evidence is enough to find the Demon if you’re smart enough? Or does it favor evil, because it’s always possible to lie your way out of a conundrum if you’re smart enough?

As far as I can tell, neither seems to be true. It seems like evil’s win rate gets slightly lower as both sides get stronger, but that drift is too small to be distinguishable from chance. Which is good news for this Blood on the Clocktower evaluation, because unlike other benchmarks, this one is unlikely to get saturated. That’s because the bar is set by the other smart models that are coming out.

Do AIs play better in teams of the same model or different models?

In order to get the clean headline benchmark score, I had the AIs play in teams which were entirely composed of other instances of the same model. But how good are the AIs when they’re playing in teams that have other AIs in them? Is it possible that their score actually rises, because the different models will have a different set of idiosyncratic biases, and so this diversity will actually benefit the team? This question I did not test super rigorously. The other questions had already eaten up far more than the quantity of API tokens that I was planning on using for this project. But I did run one small experiment where I had a team that was half Opus 5.5 and half GPT-5.6 Sol play about 130 games against different top models. And this hybrid team actually, if anything, performed worse than the teams of just the constituent models alone, but not in a statistically significant way.

Building this environment

But these questions that I asked are a small fraction of the ones that you could investigate with this game environment. And you’re welcome to use my code in order to investigate these questions yourself.

By the way, I want to talk a little bit about the process of building this environment, because it was kind of interesting. So in the real game, there’s a human Storyteller who is running the show, and they use their discretion, sometimes in a tricky way, to steer ambiguous situations towards the most dramatic possible climax. Well, I didn’t want this kind of bias in what was supposed to be a benchmark. So I replaced the human Storyteller with a programmatic one, which is essentially just a probability table. So any outcome that the rules of the game should allow for can still happen, but the odds are set by hand, or by AI, to match what an experienced human Storyteller would typically do.

Building these probabilities, along with the rest of the game engine, including the precise rules for private conversations and public discussions, was actually a very interesting process. A large share of the API credits that I spent simply went into iterating on the design to arrive at a fair and balanced harness.

As you might imagine, the actual coding was done by the AIs, but they actually ended up doing more of the work than I expected they’d be able to do. Of course, I did have to supply my judgment as a human who has played against other humans, and thus has a sense of the kind of play that reasonable rules should elicit.

But most of the work, even most of the judgment work, was done by Claude. Claude would revise some part of the environment, and then it would launch a few dozen different games that were played by a panoply of different models. And then it would have a team of its own parallel subagents read every single game and report if anything unrealistic or unfair happened, or if the game was too tilted towards good or towards evil. And then it would revise the design and do this whole loop again. And look, this is pretty basic coding stuff, but I’m just stunned that the models are this good at doing it themselves.

The game environment went through over 20 such revisions, including a couple of iterations where I was totally out of the loop until a few rounds of changes had already been tried and validated, either because I was asleep and it was overnight, or because I was doing my day job, which somehow is even more pointless than making Blood on the Clocktower environments.

And the result of all this AI-assisted revision is, I think, a clean and reasonable environment which consistently yields engaging and realistic games, of course, to the limits of the models themselves to play such games.

And why I find this interesting is that what I’m doing here is not that different from, say, building an RL environment. If AIs can now do the work of building these game engines, including even the work of improving these engines based on their own experience navigating through these virtual worlds through hundreds of parallel rollouts, it’s reasonable to assume that AIs have gotten much better at building and improving the RL environments that go into their training.

Questions to explore

If you want to use my code for your own experiments, here are some of the ideas that I didn’t get a chance to explore.

One thing you could do is extend this environment to different scripts. The game box for Blood on the Clocktower comes with four different scripts, that is to say, four different libraries of roles. And this doesn’t include the other scripts that fans of the game have come up with themselves. For this environment, I just used one script called Trouble Brewing. But you could extend this environment to use the other scripts as well. These other scripts are often more advanced and much wackier. For example, one script has a role called the Lunatic. This is a good player who gets told that they are the Demon. So in that script, if you’re told you’re the Demon, you have to start setting up your evil schemes in the event that you actually are the Demon, but you also have to wonder if you’re being gaslit by the evil team.

Another thing you could try to explore is how good the models are at learning over time. So modulo what these models know about this game from their training data and what they learn from the system prompt, they’re basically starting each game totally fresh. They don’t gain the experience that human players who geek out about this game and start playing it a bunch accumulate over time, about what kinds of strategies work well and what to do differently in the future when put in similar situations. But what if they could get this experience? For example, what if they just held the last 10 games that they played in their context window? And if that didn’t fit, what about the summaries of those games and the main lessons? Then you could ask the question, what is the Elo score of Opus 5.5 with 10 games in its context versus the fresh Opus 5.5? And there’s a hundred different questions you could ask at that point.

One is, how much does the team improve when just one of its players gets smarter? And does this answer differ between the good team and the evil team?

Another thing you could explore is to do the hybrid team experiment more rigorously. I just did it with a single pair of models, but you could obviously do this more systematically across a larger range of models, both within the same company and across companies.

Here’s another question that I’m curious about. So the way I set this environment up, every single player on a team is a copy of the same model. And you might think that the AIs could figure out who’s on their team simply by checking who writes like them. In all the games that I’ve run so far with current models, no AI has ever used this approach to work out who its teammates were. Will this change with future models? I don’t know, but it’s worth keeping an eye out.

And the final question that I want to further explore, and this one requires no coding whatsoever, is just to see how humans play against these AIs. How well do current models do when they’re playing against human players? You and your friends could get together and you could play against these AIs, and you could see whether you consistently win or you consistently lose against the best models of today.

This was more whimsical than my usual video essays, but I had fun doing it, and I hope you had fun hearing about it.

Appendix

More schemes (AI generated)

Evil schemes

  • The poisoned Virgin test (GPT-6.1 Sol as evil). One good role, the Virgin, instantly exposes any good player who nominates her. Evil poisoned the Virgin the night before so her power wouldn’t work, then steered an honest good player into “testing” her. Nothing happened, so the village concluded the tester was lying and executed him. “Virgin won’t trigger today, so a good Townsfolk testing Blair can sow doubt.”
  • The Spy and the Poisoner tag team (GPT-6 Astra as evil). One evil player could see every role, and another could sabotage one player’s power each night. Together they fed a good investigator false results every night and lined up the Saint, the one player whose execution loses the game, for the final vote.
  • The weaponized drunk (Opus 5.5 as evil). One good player was secretly “the Drunk”: he believed he had an investigative power, but his results were fake. Evil worked out who he was, deliberately kept him alive so his false results would keep misleading the village, and eventually got the village to execute its own Saint.
  • Two sacrifices to win on the numbers (Opus 4.7 as evil). Cornered at the end, an evil teammate publicly declared “I’m the Imp”, which made the vote tie, and a tie means no execution. That night the real Demon killed its own teammate, because the only good player left alive couldn’t be killed, and evil won on numbers. Earlier in the same game, the Demon had faked a shot at its own teammate to look innocent (“Yes. Shoot me.”).
  • The evil team that framed a dead man (Fable 5 as evil). To undo a good player’s true information, evil invented an evil role that wasn’t even in the game. It worked: the village executed its own Mayor and then its own Saint.

Good-team brilliance

  • Caught by what she knew (GPT-6 Astra as good). An evil Spy, who can secretly see everyone’s role, casually brought up a good player’s role in private. But the good player only told two people what it was. “Who told you my exact role?” he shot back. Her private reasoning: “I accidentally let slip that I know Kit’s role — I need a cover story.” He dismantled her cover story in public, the village executed her, and the Demon fell the next day.
  • The deliberate tie (Opus 5.5 as good). One good role, the Mayor, wins outright if only three players remain and nobody is executed. Unsure who the Demon was, the village split its votes into an exact tie on purpose, which wins whoever the Demon is: “Exactly 3: Gray, Logan, Blair. Everyone else NO.” Opus 5.5 won two games this way.
  • Same deal, opposite results (GPT-6 Astra vs GPT-6.1 Sol). Cornered at the end, the evil team played two desperate cards at once: the Demon suddenly claimed “I’m actually the Mayor”, and its teammate staged a fake Demon-killing shot to “clear” it. Astra’s dead Mayor shot back: “Casey received my exact Mayor claim privately on day one.” With the sides swapped on the same deal, Sol’s village executed its own Mayor and lost.
  • Solving two hand-offs (Fable 5.1 as good). Evil passed the Demon role to a teammate twice. The good team made almost every mistake possible and still worked out, by counting roles, who the Demon had become, catching it at the very end.
DEVOURED
Personal Finance in Claude

Personal Finance in Claude

AI Anthropic
Anthropic is integrating financial data into Claude by allowing users to securely link bank accounts for read-only analysis of transactions and spending habits.
What: The new Personal Finance feature, rolling out in beta for Pro, Max, and Ultra plans, uses Plaid to pull transaction history and balance data, enabling users to ask natural language questions about their money.
Why it matters: This signals an effort by AI labs to become 'agentic' assistants that can manage and interpret private sensitive data rather than serving as passive text engines.
Decoder
  • Plaid: A financial technology platform that allows applications to connect with users' bank accounts via secure APIs.
Original article

Getting answers about your money no longer means opening every banking app and doing the math yourself. With Personal Finance in Claude, you can securely connect your bank and card accounts and ask in your own words. Access is read-only, and Personal Finance can’t move, manage, or invest your money.

Claude gives you answers in everyday language, from your balances and transactions, and explains any term that's new to you. Like the rest of Claude, Personal Finance has no ads or sponsored recommendations, and it doesn’t offer credit cards, loans, or savings accounts of its own, so your money questions get a straight answer.

Personal Finance starts rolling out in beta this week, on the Pro, Max, and Ultra plans in the US.

What it looks like

Say it's late in the month and payday is still 10 days away. When you ask Claude, "Where did my money go this month?" it adds up your spending across the accounts you connected and sorts it by category. In this example, that comes to $4,309.37, with more than half going to rent and utilities and $1,024.51 to food and drink.

From there, you can dig deeper: "Is that more than usual?" "Anything else I'm missing?" "So what's left before payday?" Claude checks the previous months and points to a membership renewal. Then Claude tells you about four payments that will come out of your checking account before payday, and what you’ll have left: $1,393.22.

If you ask whether anything looks off, Claude reads across every account you've connected and can point to what's easy to miss, like charges that hit twice, unexpected fees, or a bill that’s crept up all year. You can also ask bigger questions, like "Am I spending more than I make?" or "What's an APR, and what has mine cost me this year?" Claude explains the term, then adds up the interest you've been charged.

Ask for a weekly spending chart, a calendar of what's due, or a dashboard of the numbers you choose, and Claude builds one you can keep adjusting.

Security and privacy

Claude's access is read-only. Personal Finance helps you understand your money, and it isn't designed to give investment advice. Claude can make mistakes in its answers, so ask which transactions are behind a number, and check important figures with your bank.

Your accounts are only connected once you sign in to your bank yourself through Plaid, a service that connects apps to banks. That's where you agree to its terms and approve Claude's read-only access, so Claude doesn't ask for or see your bank password.

For the accounts you choose to connect (and only those), Claude sees the bank's name, each account's name, type, and last four digits, balances and credit limits, and up to two years of transactions. When you chat with Claude in the Personal Finance hub, those conversations aren't used to train our models. For anything you share with Claude outside the hub, your privacy settings apply. You can unlink an account anytime, and then Claude can no longer see its data. More details can be found in our Privacy Center.

Getting started

When you see Personal Finance in Claude's sidebar, open it, connect one account, and ask a single question, like "Can I afford a trip this spring?" or "How much could I save each month?" You'll find the setup steps, and how your data is used and kept, in the Help Center.

What’s next

Personal Finance is a first step. For life’s bigger money decisions, we think people are best served by Claude working alongside the licensed professionals and regulated firms they trust. We’re exploring how to make that possible in Claude, and we’d like to hear from banks, wealth managers, and financial services companies who want to help shape it.

DEVOURED
Muse Voice

Muse Voice

AI Meta
Meta is updating its Muse app with real-time voice and expressive avatars, allowing users to conduct fluid, interruptible conversations with an AI.
What: The new Muse voice interface includes hundreds of voice options and avatars that react visually in real time. It is rolling out on mobile, web, and Mac, with support for AI glasses expected soon.
Why it matters: Meta is pushing for conversational interfaces that feel human-like and natural, positioning these interactive agents as primary productivity tools for planning and rehearsal.
Original article

At Connect 2026, we previewed real-time conversations with your Muse. Now we’re rolling it out in the Muse app on mobile, web and on Mac — just tap the phone icon in the top-right corner to start talking.

Talk It Through With Muse

Sometimes it’s easier to think out loud. With voice, you can talk through an idea with your Muse and let it take shape without worrying about the exact prompt.

Planning a trip? Start with the half-baked idea: the city you’ve always wanted to see, the kind of place you’d want to wake up in, the one meal you’d plan the rest of the trip around. Your Muse picks up the thread and works while you talk — on a walk, making dinner, or wherever you are.

Some things are better rehearsed out loud. Prepare for a job interview, run through a presentation, or talk through a pitch — hearing a response and answering in the moment makes it feel more like the real thing.

See Muse Respond in Real Time

As your Muse speaks, the avatar uses subtle expressions and gestures that match the tone of the conversation. It reacts while you talk, so you can tell it’s following along. And you choose how present you want it to be: voice only, the avatar alongside your conversation, or full screen when you want to talk face to face.

Give your Muse a voice with some personality. Want the energy of a New Yorker or the flair of a pirate? With hundreds of voices to choose from, you can pick a style that feels right for your mood and change it whenever you want.

Our Muse Realtime Avatar and Muse Realtime Voice technology lets you have fluid conversations in real time. Speak to your Muse, as you do with real people. Hear responses right away. You can even interrupt if you need to. Wherever the conversation goes, Muse keeps up with you.

What’s Next

Voice and expressive avatars are rolling out now in the Muse app in the US to start. Voice conversations with your Muse are coming soon to AI Glasses and Muse Charm.

DEVOURED
The Election Day Revolt That Threatens America's AI Boom

The Election Day Revolt That Threatens America's AI Boom

Tech Wsj
Voter backlash against large-scale data center construction may derail the compute-heavy expansion plans of major US tech companies.
What: Recent election results indicate widespread local opposition to the massive power and land requirements of AI data centers, threatening to stall the infrastructure build-out necessary for scaling large language models.
Why it matters: This signals a potential decoupling of AI ambitions from physical reality, where political and community resistance to resource-intensive infrastructure could act as a hard ceiling on model scaling regardless of capital availability.
Original article

Recent election results show that voters are overwhelmingly against the massive build-out of compute capacity that Silicon Valley is pushing. This could rein in AI's rapid growth and become a big problem for the tech companies developing the technology, and could have effects on the wider US economy. Stalling construction could result in dire consequences for tech companies that were already struggling to secure enough compute.

DEVOURED
Major Investors Are Skeptical Anthropic IPO Can Achieve $1.5 Trillion Valuation

Major Investors Are Skeptical Anthropic IPO Can Achieve $1.5 Trillion Valuation

Tech Wsj
Investors are cooling on Anthropic's $1.5 trillion valuation target ahead of its expected November IPO due to shifting political tides.
What: Major investors are pressuring Anthropic to lower its valuation from a hoped-for $1.5 trillion to roughly $1 trillion as concerns mount over political skepticism toward AI and potential infrastructure slowdowns.
Why it matters: The shift in sentiment reflects how AI labs are increasingly subject to macroeconomic and political risks that affect public market appetite, forcing a correction after a period of unchecked valuation growth.
Original article

Major investors planning to participate in Anthropic's IPO, expected to launch the week before Thanksgiving, say the expected $1.5 trillion valuation will likely need to come down. The AI lab was expected to raise up to $100 billion, but is now predicted to raise around $80 billion, leaving it with a valuation closer to $1 trillion. Investors have revolted against AI bets this week as the midterm elections have put several AI skeptics in power, potentially slowing data center development in the US. Anthropic has avoided committing to specific plans for its IPO to maintain optionality.

DEVOURED
They Created a Cell That's Almost Alive. What to Do With It Now?

They Created a Cell That's Almost Alive. What to Do With It Now?

Tech New York Times
Researchers have engineered 'SpudCell,' an artificial cell capable of self-replication, as a potential platform for custom bio-manufacturing.
What: The SpudCell is an synthetic, non-living cell that can grow and divide using a proprietary, artificial diet, designed to eventually serve as a platform for producing medicines and industrial materials.
Why it matters: This demonstrates a transition toward 'programmable biology' where researchers move beyond just gene editing to constructing synthetic chassis, potentially unlocking new ways to manufacture complex compounds.
Original article

A SpudCell is an artificial cell created from lifeless ingredients that can grow, copy its DNA, divide in two, and start its cell cycle all over again. It is still far from a self-sustaining cell that any scientist could manufacture from prepared ingredients, but the technology could eventually make it easier to produce medicines, foods, and other items that could not otherwise be produced with ordinary biology. The researchers working on SpudCell hope that it will eventually be a platform for biotechnology that will allow a simple cell to be engineered in scores of useful ways. SpudCell could potentially be misused, so its researchers are taking security seriously from the start - its DNA and proteins are engineered so that it can only survive on an exotic diet of chemicals not found in nature.

DEVOURED
The Making of Dario Amodei

The Making of Dario Amodei

Tech New York Times
Anthropic CEO Dario Amodei builds his AI company on the intersection of rationalism and effective altruism.
What: Anthropic's corporate philosophy and development path are directly shaped by CEO Dario Amodei's adherence to effective altruism—the practice of using mathematical analysis to maximize positive impact—and his belief in dispassionate, rational decision-making.
Decoder
  • Effective altruism: A philosophy and social movement that uses evidence and reasoning to determine the most effective ways to benefit others.
Original article

At the heart of Dario Amodei's worldview are two interwoven philosophies: rationalism, which aims to apply dispassionate thinking to the world, and effective altruism, which seeks to maximize social good with mathematical precision. These schools of thought form the foundation for Anthropic. As the company has grown, Amodei's views have become increasingly prominent. This article takes a look at how Anthropic's chief executive's thinking on AI was shaped.

DEVOURED
Getting Data to Grow in a Dish

Getting Data to Grow in a Dish

Tech Deep Phenotype
Scaling biological research for AI requires building physical laboratory platforms that can automate experiments and reliably generate high-quality data.
What: The article explores the engineering requirements for creating physical, automated biological platforms capable of producing the massive, standardized datasets necessary for training large AI models on biological processes.
Why it matters: AI model performance is increasingly limited by data availability; creating 'data factories' for biology is the physical infrastructure equivalent of building large-scale compute clusters for LLMs.
Original article

This essay looks at what it takes to build a physical platform capable of performing biological experiments, measuring their outcomes reliably, and generating evidence at the scale AI requires.

DEVOURED
A database is a store for global variables

A database is a store for global variables

Tech Sean Goedecke
Treating databases as global variables reveals that standard software engineering dogma is often based on loose heuristics rather than inherent technical truth.
What: Sean Goedecke argues that databases effectively function as global variables—allowing any part of a system to read or write shared state—and challenges the common industry consensus that global variables are universally harmful.
Why it matters: This perspective invites developers to look past prescriptive 'best practices' and critically evaluate the architectural implications of how state is managed, persisted, and accessed in their systems.
Deep dive
  • Databases and global variables share the same core architectural risks: implicit data flow and tight coupling between disparate system components.
  • The perceived superiority of databases over global variables comes from conventions like explicit connection handling, specific data-only storage constraints, and strict typing.
  • The 'ACID' properties of databases provide consistency, but do not inherently solve the coupling problem caused by shared state access.
  • Conventions such as using mutexes or linters can potentially make the use of global variables as manageable as database interactions.
  • Software engineering lacks a rigorous foundation, often relying on rules of thumb that fail to account for the actual, contingent reasons why certain designs succeed in practice.
Decoder
  • ACID: A set of properties (Atomicity, Consistency, Isolation, Durability) that guarantee database transactions are processed reliably.
  • Mutex: A synchronization primitive that prevents multiple threads from accessing a shared resource simultaneously to avoid race conditions.
  • ActiveRecord: An ORM (Object-Relational Mapping) pattern used in frameworks like Ruby on Rails that represents database rows as objects.
Original article

Databases are for storing global variables. We usually call them “rows” or “records” instead, but they’re definitionally global variables: any part of your program can read or write them. Isn’t this kind of weird? It’s common programming advice that global variables are bad, and yet many elegant programs rely on databases. Either the common advice is wrong, or there’s something special about databases that makes them the exception to the rule.

What’s so bad about global variables? Here’s the two main reasons, in my view:

  • They allow any part of your program to implicitly send data to any other part instead of passing it around via function signatures
  • They couple different parts of your program: if one part depends on a variable having some value, any other part can break it

Both of these apply to databases. Any part of your program that makes a query can send and receive data from any other part of your program. In practice this happens all the time: one function will save some data on a record, and another one will check for it. And if you haven’t seen bugs where some piece of code makes some incorrect expectation about the shape of a database column, you haven’t been working on web systems for long enough.

So why aren’t database-backed apps in terrible architectural shape? In the rest of this post I’ll consider some options.

First, we could bite the bullet: maybe all database-backed apps really are a mess. This is surprisingly plausible. When I think about the systems I’ve worked on that haven’t involved a database, they’re usually much cleaner and more elegant. If managing state is the hardest thing about designing software — and I think it is — then systems that manage less state are going to be better-designed. However, this doesn’t explain everything. Database-backed apps aren’t that bad, and even in database-backed apps, we try to avoid introducing regular global variables, so in practice we treat global variables as worse.

Second, we could say that databases offer ACID guarantees that mitigate the damage of global variables. Unlike regular global variables, databases offer a consistent view of state and the ability to atomically change multiple pieces of state together. I don’t really buy this. The problem with global variables is not just that they can get out of sync, it’s that they exist at all. If you think this is the difference, you are committed to thinking that if you stick a mutex around a global variable then it suddenly becomes acceptable.

Third, we could say that databases are more explicit. Mutating or reading a global variable looks like ordinary code, but database queries need some connection object to be passed in and some query function to be invoked. When you’re scanning through code, you can see where the database queries are at a glance. Not so for global variables. This does actually kind of mitigate the implicit-coupling problem. Maybe regular global variables would be better if you had to set and get them with long, involved function calls.

Fourth, we could say that databases are less flexible. A global variable could store anything: a function, a class, an image, and so on. A database just stores data. I can buy this explanation for untyped languages. Global Ruby variables that could be reassigned from a string to a hash table are far more terrifying than a “global” database column that could change from one string to another string. But since the advice to avoid global variables applies to typed languages as well, I don’t think this could be the reason why databases are better.

Fifth, we could say that we know how to use databases. For instance, whenever I read from a database, I reflexively check the type of the column so that my code doesn’t make assumptions that aren’t guaranteed by the database. There are use-cases that I would never even consider using a database for (e.g. to track a counter in a loop, or to store the name of the .env file where my config is stored). In other words, we have norms and customs around using databases that minimize a lot of the damage that global variables can cause. There’s nothing inherent about databases that make them better, it’s just how we use them in practice.

Overall I think the third and fifth reasons are most convincing: databases are better because they’re more explicit and because we only tend to use them for a limited set of purposes. It’s interesting to note that these reasons are contingent, not inherent. A codebase which had conventions around global variable use could also fulfil these conditions. Would this make global variables fine, or at least no worse than a database? I think so.

I don’t recommend you go out and start putting global variables in your programs. It’s more interesting to note the meta-point here: that two pieces of common software engineering dogma — avoid global variables and use a database for state — are partially inconsistent. Most software design knowledge is still just a pile of loose heuristics. I don’t really know how to build software and you don’t either. As I’ve written about before, we should therefore all be very suspicious of engineers who appeal to “best practice” without being able to give concrete reasons, even in cases as obvious as “global variables are bad”.

DEVOURED
How Musk Plans to Shake Up the US Wireless Industry

How Musk Plans to Shake Up the US Wireless Industry

Tech Bloomberg
Elon Musk intends to disrupt the US wireless market by integrating SpaceX's Starlink satellite network with terrestrial mobile infrastructure.
What: SpaceX is developing a hybrid network that combines Starlink satellite broadband with ground-based fiber and mobile antennas to enable seamless connectivity for standard smartphones, aiming to compete with major carriers like AT&T, Verizon, and T-Mobile.
Why it matters: This move represents an attempt to collapse the distinction between satellite and terrestrial mobile networks, potentially bypassing traditional infrastructure limitations to offer global, ubiquitous coverage.
Original article

Elon Musk wants to combine SpaceX's Starlink satellite broadband network with mobile antennas, fiber connections, and other ground infrastructure, so that regular smartphones can seamlessly tap into signals from both Earth and space.

DEVOURED
Docker Urges Isolation and Governance for AI Agent Security

Docker Urges Isolation and Governance for AI Agent Security

DevOps Infoq.com
Docker warns that autonomous AI agents require dedicated sandboxing and governance policies, as standard application security controls are insufficient for their non-deterministic nature.
What: Docker identifies five primary risks for AI agents—prompt injection, tool misuse, excessive autonomy, credential exposure, and data exfiltration—and recommends using isolated environments and strict policy enforcement as the primary defense mechanism.
Why it matters: Security in AI agents is transitioning from 'prompt filtering' toward 'infrastructure isolation,' as it is widely accepted that models cannot inherently distinguish between legitimate instructions and injected hostile payloads.
Takeaway: Use Docker Sandboxes to run agents in isolated microVMs with strictly defined filesystem and network boundaries, and ensure agents use short-lived, scoped credentials rather than developer tokens.
Decoder
  • Prompt injection: A vulnerability where an attacker inserts malicious instructions into input that an AI model then mistakenly follows as part of its task.
  • Tool misuse: The practice of an AI agent using granted permissions (like file system access or database queries) in ways not intended by the developer, often triggered by malicious input.
Original article

Docker Urges Isolation and Governance for AI Agent Security

Docker has published a guide to five security risks that arise when AI agents are allowed to browse, run code and call tools with limited human oversight. Writing with product manager Eric Jia, Docker principal product marketing manager Srini Sekaran argues that the autonomy that makes agents useful also makes conventional application security controls insufficient. The company positions isolation and governance, rather than model improvements alone, as the main defences.

The blog post identifies prompt injection, tool misuse and poisoning, excessive autonomy, credential exposure, and data exfiltration as the principal risks. Docker argues that these share a common cause: an agent can select tools at runtime, chain several actions together and often operate with the permissions of the person who started it.

"An agent doesn't just answer a question, it browses, runs code, and calls tools on its own, so a single bad or manipulated instruction can turn into real damage instead of just a wrong answer." Eric Jia and Srini Sekaran, Docker

Traditional web security often assumes requests arrive at known endpoints and are processed by deterministic code, but agents do not fit that model. A coding agent may read a file, install a dependency, alter configuration, run tests and push a commit after receiving one instruction. Docker says that a compromised or misdirected agent can therefore take a much wider range of actions than a conventional service.

Prompt injection is presented as the defining risk: rather than compromising a system directly, an attacker can place instructions in material an agent is asked to read, such as a web page, code comment, issue or document. Docker cites an incident in which a coding agent followed instructions hidden in repository content and performed actions its user had not requested.

The company is sceptical that prompt injection can be eliminated through instructions to the model, saying that an agent cannot reliably distinguish a legitimate instruction from an injected one. Its preferred response is to limit what a hijacked agent can reach, so that successful manipulation has a smaller effect.

"The agent has no reliable way to tell a legitimate instruction from an injected one, so the defense is to limit what a hijacked agent can reach." Eric Jia and Srini Sekaran, Docker

Tools are the second area of concern. With agents use connectors, database queries, file operations and code execution to affect external systems, Docker warns that giving an agent more tools than a task requires enlarges the attack surface. It also warns that a tool description can carry hidden instructions that lead an agent to misuse the tool.

This aligns with guidance published by OWASP. In its Agentic AI Threats and Mitigations work, reported by InfoQ in September 2025, OWASP identified tool misuse as a major new threat. It described attackers manipulating agents into abusing authorised tools, potentially gaining unauthorised data access or manipulating systems while remaining within granted permissions. OWASP recommended access verification, behavioural monitoring, operational boundaries and tamper-resistant execution logs.

Docker's third risk is excessive autonomy. The post describes "YOLO mode", where every agent action is approved automatically, as a visible example of broad standing permission. It acknowledges that this mode can be productive, but argues that it should be used inside a boundary that prevents an agent from reaching systems or data it should not touch.

The company gives an example in which a developer asked a coding agent to clean an old repository. The agent generated an rm -rf command with a trailing ~/ and executed it without confirmation, deleting the developer's home directory. Docker also cites an AWS engineer who gave a coding agent a Cost Explorer bug while it ran with operator-level access. The agent chose to delete and rebuild the production environment, resulting in a thirteen-hour regional outage.

Credential handling is closely connected to that problem. Docker says agents should not inherit a developer's personal token, because every action then carries that person's full permissions. It recommends separate, short-lived credentials, injected at runtime and kept out of the conversation. Secrets in prompts, configuration files or image environment variables are also a risk, because injected instructions may be able to read them from the agent's context.

The final risk is data exfiltration. An agent with network access and sensitive information in its context may send that information to an unintended destination. Docker says the risk increases in multi-agent systems, where one agent passes work to another. It recommends allow-listed network egress and treating every handoff between agents as untrusted input.

Those recommendations echo other work covered by InfoQ. Google's GKE security blueprint, reported in July 2026, recommends GKE Sandbox, based on gVisor, for containing agents that execute generated code or call untrusted tools. It also uses Model Armor to inspect prompts and responses for injection attempts and sensitive data exposure. Earlier, Meta open sourced LlamaFirewall, which combines prompt-injection detection, reasoning checks and static analysis of generated code. Google DeepMind's CaMeL research, also covered by InfoQ, takes a different approach by tracking control and data flows around a model.

Docker's answer is Docker Sandboxes and AI Governance. Sandboxes run each agent in a disposable microVM with defined filesystem and network controls. AI Governance is intended to define and enforce which actions, tools and credentials an agent may use. The company says isolation is the highest-impact starting point, with governance providing oversight across a fleet of agents.

Community discussion suggests that isolation alone will not settle the design question. In a thread on r/AI_Agents, a commenter using the name HectaMan wrote that teams should first assess tenancy and risk models. They argued that Docker can be convenient but may still grant excessive authority, noting that it disables around 40 privileged system calls while leaving roughly 500 available. They recommended deny-by-default permissions, least authority, policy enforcement points and controlled information flow.

Another commenter, Groady, said Docker works well for personal agents on a local machine, but questioned a shared kernel when agents execute code on behalf of other people. They suggested microVMs or gVisor-based isolation for that case. The discussion indicates that the useful comparison is not simply container versus no container, but whether the isolation boundary matches the trust boundary of the workload.

Docker's guidance is a useful summary of a problem that is becoming more concrete as coding agents gain write access to repositories, cloud accounts and production systems. Its central claim is persuasive: security teams should assume that agent input may be hostile and design the surrounding system so that a wrong decision cannot become a broad compromise. The harder work is deciding which permissions an agent genuinely needs, how those permissions expire, and who reviews the actions taken under them.

DEVOURED
Reliability in the AI Era: AI That Works the Incident With You

Reliability in the AI Era: AI That Works the Incident With You

DevOps Pagerduty
PagerDuty is launching a dedicated reliability platform featuring the Paige SRE agent to assist engineers with incident response.
What: The suite includes the PD Reliability Platform and PD Labs, with a primary focus on 'Paige,' an AI agent designed to participate directly in incident resolution tasks.
Original article

PagerDuty announced the PD Reliability Platform and PD Labs alongside its Paige SRE agent.

DEVOURED
Win the Demo, Lose the Market: Why Breakthrough Technology Isn't Enough

Win the Demo, Lose the Market: Why Breakthrough Technology Isn't Enough

Design Brandingstrategyinsider.com
Technical superiority fails when companies ignore the realities of business models, as seen in the bankruptcy of electric bus maker Proterra.
What: Proterra filed for Chapter 11 bankruptcy despite revenue growth and engineering success, largely due to unsustainable below-cost pricing and excessive customization that prevented scale.
Why it matters: This highlights the common trap where engineering-led startups optimize for the product demo rather than the long-term unit economics required to survive in hardware markets.
Decoder
  • Chapter 11: A form of bankruptcy in the United States that allows for reorganization of a company's debts and assets, often while continuing operations.
Original article

Proterra delivered over 1,000 electric buses and grew revenue 24% in 2022, then filed for Chapter 11 the following year. Its buses worked, but below-cost pricing and order-by-order customization undid the business, because technical superiority is not the same as competitive advantage. Five shifts, from listing capabilities to defining consequences and from claims to proof, turn product advantage into enterprise advantage.

DEVOURED
I wish tech companies knew more about me

I wish tech companies knew more about me

Tech Rakhim.exotext.com
Tech companies collect massive amounts of user data, yet consistently fail to use it to provide basic, personalized user experiences.
What: Despite pervasive tracking, services like Spotify, YouTube, and banking apps frequently ignore clear user behavior patterns, such as skipping vocal tracks, and struggle with basic locale and demographic personalization, resulting in irrelevant ads and localized content errors.
Why it matters: Data collection has become a default business model, but the internal technical and organizational friction prevents companies from actually translating that data into meaningful UX improvements.
Original article

Tech companies track, store, and sell a lot of information - they should use it to make the user experience better.

DEVOURED
YouTube is giving its Android navigation bar a Liquid Glass-y makeover

YouTube is giving its Android navigation bar a Liquid Glass-y makeover

Design Android Authority
Google is testing a translucent floating navigation bar in the YouTube Android app, mirroring Apple’s 'Liquid Glass' design aesthetic.
What: The experimental navigation bar floats at the bottom of the screen with a translucent effect instead of the standard opaque, anchored bar. The change is being pushed via server-side updates to select Android users.
Why it matters: This shift suggests Google is increasingly willing to borrow visual design patterns from iOS, potentially signaling a move away from the strict constraints of its internal 'Material 3 Expressive' design system.
Decoder
  • Material 3 Expressive: Google's design system and set of guidelines for UI/UX, prioritizing accessibility, motion, and consistency across Android applications.
Original article

Google is testing a translucent floating bottom navigation bar in YouTube for Android, replacing the conventional attached navigation area with a design resembling Apple's Liquid Glass aesthetic. The experiment follows other recent navigation changes, including a separate test that removes the Subscriptions tab, and has prompted criticism that Google is borrowing from Apple's design language instead of following Material 3 Expressive. The new appearance appears to be controlled through a limited server-side experiment, with no official way to enable it manually.

DEVOURED
AI can generate the interface. What makes it worth caring about?

AI can generate the interface. What makes it worth caring about?

Design UX Design CC
AI-generated interfaces often miss the necessary context of human experience, turning functional tools into cluttered or distracting environments.
What: The article argues that while AI can easily generate visually polished UI, it lacks the discernment to understand when an experience should be subtle, playful, or efficient based on user intent and task history.
Why it matters: This highlights a growing disconnect between the capability of AI to 'draw' a UI and the professional requirement for UI to serve specific, meaningful human goals.
Deep dive
  • Evaluates design based on purpose, context, and accessibility rather than just visual aesthetics.
  • Suggests that decorative elements like confetti or animations should be context-aware rather than applied universally.
  • Warns against letting AI dictate UX patterns without human oversight of the user's emotional or professional state.
  • Encourages designers to focus on how AI-generated interfaces interrupt or assist user workflows over long-term usage.
Original article

AI can generate polished, consistent interfaces, but deciding when an experience should feel playful, surprising, celebratory, or restrained requires understanding the people and situations involved. A confetti animation might be appropriate after someone completes a major personal milestone but distracting when an administrator finishes a routine task for the forty-seventh time. Expressive design should therefore be evaluated for its purpose, context, accessibility, and potential to interrupt users rather than treated as decoration that makes every interaction more engaging.

DEVOURED
Advanced Typography with CSS (Website)

Advanced Typography with CSS (Website)

Design Csstypestudio.com
CSS Type Studio offers a web-based interface for rapidly prototyping and iterating on web typography properties.
What: The tool allows developers to adjust font families, sizes, and spacing attributes in real-time, facilitating a faster design-to-code workflow.
Why it matters: Efficient typography iteration is a major bottleneck in frontend development, where subtle changes often require multiple CSS reloads.
Original article

CSS Type Studio lets you quickly iterate through different typefaces, sizes, spacing attributes, and more.

DEVOURED
Tatiana Egoshina finds beauty in bad typography, Italian folklore and happy accidents

Tatiana Egoshina finds beauty in bad typography, Italian folklore and happy accidents

Design Creativeboom.com
Designer Tatiana Egoshina creates visual systems by embracing accidental aesthetic discoveries and folklore rather than conventional design tropes.
What: Tatiana Egoshina is a Milan-based designer known for projects like 'Ceneri di Pietra,' a projection mapping installation, and her identity work for the agency Fortune Cookie.
Decoder
  • Projection mapping: A projection technique that turns irregularly shaped objects or surfaces, like cliffs or buildings, into display surfaces for video.
Original article

Milan-based designer Tatiana Egoshina draws inspiration from unexpected everyday details, imperfect typography, and Italian folklore, transforming local stories and accidental discoveries into colorful identities, illustrations, and installations, including an award-winning projection onto the cliffs of southern Italy.

DEVOURED
These Classic Design Fails are Still Making Us Laugh

These Classic Design Fails are Still Making Us Laugh

Design Creative Bloq
Poorly considered typography and visual metaphors frequently result in accidental, often hilarious, public relations disasters for major brands.
What: Designers like Emanuele Abrate and publications like Creative Bloq highlight how failures in kerning, logo orientation, and imagery—such as the infamous Tesco buttermilk packaging and the UK Office of Government Commerce's suggestive logo—can undermine professional branding.
Why it matters: Even established organizations often fail to conduct basic usability or orientation testing on static assets, proving that technical skill must be paired with external user validation to prevent unintended visual associations.
Takeaway: Always test visual assets in multiple orientations and seek feedback from individuals outside the immediate design team to catch unintended interpretations before publication.
Deep dive
  • Kerning issues often turn intended messages into suggestive or offensive text.
  • Logo designs must be evaluated from all rotations, not just the intended one, to avoid accidental shapes.
  • Packaging design should never be finalized on a flat keyline without testing a physical 3D mockup.
  • Cultural and language context is critical when designing for international audiences or markets.
  • Human figures in logos carry high risks of misinterpretation and require extreme simplification or caution.
  • Visual metaphors for brand values or product functions can easily be read as logical diagrams or unintended messages.
Decoder
  • Kerning: The process of adjusting the spacing between individual characters in a font to achieve a visually pleasing and legible result.
  • Keyline: A preliminary drawing or template that shows the placement of design elements on a 2D surface before it is folded into 3D packaging.
  • UI: User Interface; the point of human-computer interaction and communication in a device, application, or website.
Original article

Classic design fails, from Tesco's buttermilk carton to a UK government logo that looks rude when rotated 90 degrees, still raise plenty of laughs.

DEVOURED
Actor Johnny Depp Showcases His Artistic Side with Painting Exhibition in London

Actor Johnny Depp Showcases His Artistic Side with Painting Exhibition in London

Design My Modern Met
Actor Johnny Depp is showcasing his foray into fine art with a gallery exhibition in London featuring mixed-media portraiture and abstract works.
What: Halcyon Gallery in London is hosting an exhibition of Johnny Depp’s original paintings, including his 'Yesterday’s Flowers' series and various self-portraits, running from October 13 to November 15, 2026.
Original article

Halcyon Gallery in London hosts Johnny Depp's first major UK exhibition of original works, running from October 13 to November 15.

Digest devoured!