Loading digest...
Nov 19
1 / ?
AI llm

Gemini 4 Neon

Google launched Gemini 4 Neon, a model designed for fast, multi-step agentic coding and science workflows at a lower price point.

Summary

What: Gemini 4 Neon is priced at $3 per million input tokens and $15 per million output tokens. It features a 1 million-token context window and ranks high on the Artificial Analysis Intelligence Index (61) and Agent Arena Index.
Why it matters: The focus on lower-cost, high-reasoning models indicates a shift toward deploying agentic systems in production where token efficiency per task is as critical as raw model intelligence.
Takeaway: Developers on the Gemini API paid tier can access Neon in Google AI Studio; cybersecurity teams should contact their account team for the Fairwind Program access.

Deep Dive

  • Performance: Neon ranks #3 overall on the Artificial Analysis Intelligence Index.
  • Efficiency: Offers a 95% discount on cached input tokens compared to uncached rates.
  • Capabilities: Strong performance on coding benchmarks (SWE-sweep) and multi-file debugging.
  • Safety: Includes improved resistance to indirect prompt injection and reduced fabrication rates.
  • Use Case: Designed for long-running, tool-heavy agent workflows rather than simple chat.

Decoder

  • Context compaction: A technique used by AI agents to summarize or prune historical conversation data to fit into limited memory or save costs.
  • Pareto frontier: A set of choices that are optimal because no one criterion can be improved without degrading another.
  • Agent Arena Index: A benchmark testing how well AI models perform in multi-step, real-world agentic scenarios.
  • Chain-of-thought: A prompting method that encourages models to explain their reasoning step-by-step before providing a final answer.

Original Article

Introducing Gemini 4 Neon

Today, we’re introducing Gemini 4 Neon — bringing frontier-level intelligence with fast end-to-end task completion across complex software engineering, knowledge work, and science workflows.

Neon ranks ahead of comparable models and #3 overall with a score of 61 on the Artificial Analysis Intelligence Index at its xhigh thinking level, landing just behind larger, slower models. On the Vals Index, Neon ranks #2 and lands on the Pareto frontier. Beyond just pushing on raw model capability, we’re continuing to make our models better to work with, Neon ranks #2 on steerability (adapting cleanly to mid-task user corrections) on the new Agent Arena Index. Neon also excels at multi-step instruction following and builds on our ongoing progress to curb fabrication, recording our lowest fabrication rate yet in internal Google Antigravity testing.

The model is priced at $3 per million input tokens ($0.15 per million cached input tokens, a 95% discount) and $15 per million output tokens, with a 1 million-token context window.

Gemini 4 Neon is rolling out today in the Gemini API in Google AI Studio, Gemini for business (via API and model dropdown), for paid Google AI Pro and Ultra subscribers in Google Antigravity, and for Pro and Ultra subscribers in the Gemini app.

Delivers across enterprise, analytical, and scientific work

Enterprise work lives in spreadsheets, PDFs, charts, audio, and video. Neon can synthesize across all of these inputs in a single 1 million-token context window and turns inputs into structured deliverables. Independent evaluations rank Neon as one of the top models and on benchmarks like the Vals Index, it ranks #2 (70.9%), and reaches #1 on both the Legal Research Bench and Tax Agent Bench.

Neon also shows strong wins across categories on Surge AI, ranking #1 on most benchmarks across finance, accounting, spreadsheet modeling, and complex constraint following. It also scores 73.5% on Chartography for reading dense professional charts and performs on par with leading models on Agents' Last Exam v1.1 (75.8%). It achieves #1 overall on both Zapier’s AutomationBench (56.3%) and Andon Labs' Vending-Bench 2 ($16,843), a long-horizon simulation of running a business. Finally, it debuts #2 globally with a score of 1336 on Arena's new Agent Arena Index across 4,200+ real-world agent sessions.

On scientific and mathematical reasoning, spanning quantitative analysis, mathematics, and technical research problems, Neon is best in class on Terminal-Bench Science (70.5%), RiemannBench (84.0%), and HLE-Diamond (71.3%).

Built for production-ready code

Engineered for long-running agent workflows, Neon sustains performance through complex, tool-heavy tasks end-to-end — whether running standalone or acting as a fast, high-judgment Orchestrator directing parallel Hydrogen subagents in Google Antigravity. It cuts down on redundant file reads, shares progress as it works, and handles context compaction reliably in long sessions.

Across core developer and researcher workflows, Neon achieves frontier performance and is competitive with the leading models in its class, ranking #1 overall on the Artificial Analysis Coding Agent Index (58.6), with a score of 65.2% on Terminal-Bench 4.1 and 46.2% (at its default high setting) on FrontierCode 2.0. For production-ready code, Neon handles multi-file debugging and refactoring across repositories with targeted, surgical edits. On SWE-sweep, it already leads on the mini-SWE harness (12.8%) and more than triples to a state-of-the-art 39.0% in Google Antigravity showing what the Antigravity harness unlocks.

Driving Blender MCP in Google Antigravity, Gemini 4 Neon used /swarm to build a photorealistic 3D lab bench visualizing the model names with elemental accuracy pairing Bunsen flames for Gemini 4 Carbon and Gemini 4 Hydrogen with high-voltage gas discharge tubes for Gemini 4 Argon and Neon.

In Google Antigravity, Gemini 4 Neon wrote a first-person WebGL2 freeride ski simulator from scratch on real Mont Blanc and Chamonix elevation terrain — combining 10,200 lines of custom shaders, 120 Hz ski physics across six alpine lines, dynamic carved tracks, slab avalanches, and spatial Web Audio with zero pre-made assets.

Using /swarm in Google Antigravity, Gemini 4 Neon pulled archival photos to recreate Alan Turing’s 1936 study at King’s College, Cambridge in interactive 3D — from King’s Chapel outside to Room X.8 inside, complete with a working Universal Turing Machine running on his desk.

In Google Antigravity, a Gemini 4 Neon agent swarm turned a single image into a 100,000-cell Google Sheet with zero embedded images and zero Apps Script — using over 500,000 live spreadsheet formulas to run edge detection, map 3D depth, and relight the scene across six interactive modes.

Brings efficiency and control to production-grade workflows

We’re refining thinking levels with each new model release to give teams finer control and a smoother progression from one tier to the next. Neon’s four levels scale steadily, letting teams dial intelligence and token spend to what each workload needs.

Neon delivers high performance at a lower cost per task across third-party benchmarks. At its default high thinking level, it pairs a high Artificial Analysis Intelligence Index score with a 32% lower cost per task than Carbon. It also sits on the Pareto frontier on both the Vals index and Agent Arena at high, with roughly 50% to 80% lower cost per task than top competing frontier models. xhigh thinking adds deeper, multi-step reasoning for the hardest engineering, analytical, and scientific workloads. Neon shows its highest intelligence score here, while still costing 36%+ less per task than competing models at their highest setting.

Built for fast, low cost, frontier-level cyber defense

As agentic coding scales, generating secure code from the start is critical. Gemini 4 Neon produces more secure code than Carbon across all easy, medium, and hard challenges on AutoBaxBench, achieving state-of-the-art on the hard tier (76%).

Securing systems also means proactively finding flaws before attackers do. Penetration testing has served as a cornerstone of enterprise cybersecurity. On WebExploitBench v1.2, Neon is state-of-the-art (51.26%) at half the cost of competing large models.

To fortify existing code, Neon for cyber delivers frontier-level performance across the code hardening lifecycle — vulnerability finding, validating, and patching — all while being faster and more cost efficient than large frontier models.

  • Finding code vulnerabilities: Neon achieves state-of-the-art performance on SEC-bench Pro (90.5%), while costing roughly half as much per challenge.
  • Validating risk through exploitation: To prioritize which vulnerabilities to remediate, defenders rely on models to check which vulnerabilities are exploitable. On ExploitGym, it achieves frontier-level performance using half the tokens of Carbon.
  • Patching vulnerabilities: Fixing the root cause of vulnerabilities is a critical step in the cybersecurity defense lifecycle. Neon reaches 70.7% on Collinear’s CWE-bench v2, driving a 3.4% uplift over Carbon.

Gemini 4 Neon for cyber is rolling out to trusted defenders in the coming days as part of the Fairwind Program.

Designed for safe, dependable execution

Gemini 4 Neon builds on improvements from our Gemini 4 safety and security stack— maintaining Gemini 4 Carbon-level protections against severe misuse and prompt injection while advancing further on model alignment and agentic behavior. For a model meant to carry demanding, long-running work in production, we concentrated on:

  • Mitigating frontier misuse safety risks: Because Neon brings frontier-level capabilities to a faster, lower-cost model, we paired it with strong real-time safeguards against cyber and biosecurity misuse comparable to our Carbon protections, while declining far less legitimate work in these areas, refusing for instance just 1.98% of tasks on Terminal-Bench 4.0 and 0% on Terminal-Bench-Science.
  • Advancing alignment and disciplined model behavior: In internal coding use, alert rates from our chain-of-thought and action misalignment monitor remained below the already low baselines set by Carbon, suggesting improved alignment propensity for Neon — and that same monitor is deployed to protect Neon across external surfaces. Neon is trained to complete multi-step work without cutting corners, fabricating results, or overstepping user boundaries — continuing to improve the balance between following through on requests and staying within scope. It matched Carbon with 0.0% cheating on Terminal-Bench 4.0 and took shortcuts on just 2.45% of tasks on our coding cheating evaluation (the lowest rate of any Gemini 4 model). It also achieved a 0.09% misaligned action rate on our agentic safety suite and a 99.2% pass rate on our agent honesty evaluation. On our agentic behavior evaluation, Neon builds on Carbon’s strong baseline by further reducing under-service by 43%–56% and overreach by 15%–35% across different effort levels.
  • Protecting users from indirect prompt injection attacks: On Gray Swan's IPI benchmark, Neon is more resilient than other models in its class when malicious instructions are planted in the web pages, emails, documents, or code it accesses. We found that with real-time safeguards at its highest thinking level, Neon resisted every attack within this Gray Swan benchmark, matching the 0.0% attack success rate reached only by other Gemini models.

For more details, see the Gemini 4 Neon model card.

Built for deeper analysis

In the Gemini app, Gemini 4 Neon excels at work that requires frontier-level reasoning and fast responses.

  • Higher-quality writing and knowledge work: Neon writes clearly, with well-structured responses and a natural, direct tone. It reads uploads like spreadsheets, PDFs, and photos more precisely, turns dense material into helpful reports and summaries, and pulls in relevant details from Google apps like Gmail and Docs.
  • Reliable research and analysis: Neon frequently incorporates details from sources across the web to keep responses current for fast-moving topics like comparing pricing across vendors before a major purchase or pulling together a complex brief with the latest market data.
  • Faster help for tougher tasks: Tasks in Gemini can now run on Neon, working through complex, multi-step jobs more quickly and efficiently than with larger models. Get more done while stretching usage limits further when handing off tedious to-dos, like analyzing billing statements to spot why a utility charge spiked or cross-checking multiple receipts and documents to negotiate a refund.

Where Neon sits in the Gemini 4 family

Neon is built for complex coding, analytical reasoning, and production-grade enterprise workflows. While Carbon tackles your hardest, long-horizon projects and Hydrogen handles fast everyday execution, Neon balances depth and efficiency. Neon delivers frontier-level reasoning for complex, high-frequency workflows faster and more cost efficiently.

Start building with Gemini 4 Neon today

Gemini 4 Neon begins rolling out today:

  • For developers: Build with the Gemini API paid tier in Google AI Studio and Android Studio, if you’re a paid Google AI Pro or Ultra subscriber, you can try Neon in Google Antigravity and all Pro and Ultra subscribers can try it in AI Studio.
  • For enterprises: Use Gemini 4 Neon in Gemini for business (via the API or model drop-down) and Google Antigravity.
  • For consumers: If you’re a Google AI Pro or Ultra subscriber, you can select Gemini 4 Neon from the model drop-down in the Gemini app.
  • For cybersecurity defenders: Eligible Fairwind Program members will begin receiving access over the next few days. To request access to the Fairwind Program, contact your Cloud account team.
AI mldevops

How Meta Uses AI Agents to Scale ML Innovations Across Ads Ranking Models

Meta estimates that AI agents now handle over 60% of their ads ranking model improvements, yielding 3x higher engineering productivity and $45M in savings.

Summary

What: Meta’s 'technique propagation' system uses autonomous agents to identify ML advancements, generalize them across heterogeneous models, and automate the experimentation and training process.
Why it matters: This reveals how large-scale tech companies are moving beyond simple LLM code generation to 'agentifying' the entire ML development lifecycle to solve combinatorial scaling problems.

Deep Dive

  • Discovery: Agents prioritize technique-model combinations by expected impact.
  • Generalization: Agents adapt techniques across different model architectures using template-driven and bespoke approaches.
  • Adoption: Agents automate training loops, monitor convergence, and manage infrastructure capacity.
  • Evaluation: Each stage uses specific metrics (precision/recall for discovery, cost/performance for training) rather than just final A/B testing.
  • Productivity: Agents enable engineers to oversee experiments at scale rather than manually managing individual model runs.

Decoder

  • Technique Propagation: The process of applying successful ML architecture or training improvements from one ranking model to the rest of the model fleet.
  • Normalized Entropy (NE): A metric used to measure the predictive performance of ranking models, where lower values generally indicate better calibration.

Original Article

  • Our previous post in this series introduced the Ranking Engineer Agent (REA), an autonomous system that generates hypotheses, designs experiments, and proves new machine learning (ML) techniques on ads ranking models.
  • Now, we’re sharing how we propagate ranking model improvements like architectural advancements and training optimizations efficiently across a large and diverse fleet of ads ranking models.
  • This post walks through this process that we call “technique propagation” and how we’re optimizing the process using AI agents.
  • Since agents began driving execution in March 2026, we estimate AI agents handle over 60% of all technique propagation. Measured against the same work before agents, early results show 3x greater engineering productivity, a median 4x reduction in training compute across select combinations, and an estimated $45M+ in compute savings by the end of the year.

Meta’s ads recommendation system is powered by a large number of distinct ads ranking models, each serving different product surfaces and advertiser objectives, and each with its own architecture, training data, and serving constraints.

Across this portfolio, ML researchers and engineers are continuously advancing the state-of-the-art through innovations we call “techniques.” A technique is anything that makes a ranking model better such as architectural advancements like Wukong factorization layers, Interformer interaction networks, richer data representations, training optimizations, or efficiency improvements in training and inference.

However, because each model has its own architecture, data, and training and serving constraints, a technique proven on one model almost never copy-pastes onto the next. At the same time, speed matters because ML techniques have a shelf life. An innovation that delivers gains today may be superseded within a couple of model development cycles. The faster proven techniques reach the full model fleet, the more value they deliver before the next generation of techniques arrive.

So how do we propagate a technique to a diverse fleet of models as quickly as possible, while minimizing engineering bandwidth and compute?

Scaling Technique Propagation

Propagating a growing inventory of proven techniques across a large fleet of diverse models creates a combinatorially expanding space of technique-model combinations to explore, where both engineering bandwidth and compute become significant constraints.

The standard way to adapt a technique is to have engineers who are domain experts manually execute adaptation. An engineer studies how a technique interacts with a specific model’s architecture, generalizes it, and tunes it to that model’s constraints. This produces the strongest results, and is still the process for our highest-revenue models, but it does not scale to all of the models in the space. Each adaptation is effort-intensive and demands deep familiarity with both the technique and the target model. So throughput is capped by engineering bandwidth while the opportunity for adaptation grows much faster.

The second constraint on propagation is compute. Every adaptation attempt requires a training run, and with a finite compute budget the question is not only which techniques to try but how to navigate the combinatorial space of configurations without spending the budget on attempts (most of which will produce suboptimal gains).

Both constraints point to the same requirement: To propagate techniques to a large number of diverse models quickly, propagation has to become standardized, automated, and able to make judgment calls.

We started by standardizing model design and automating propagation: a template-driven approach organizes models into a small set of reusable and composable building blocks, so a technique validated once at the template level propagates automatically to every model built from that template. Over the last 2 years, through standardization and automation, we have shipped 5,000+ technique-model combinations across our large, diverse fleet of models while reducing per-model engineering time by 92%. You can read more about it in our post on Standard Model Templates (SMT).

Standardization and automation handle the deterministic steps, but successful and efficient propagation still requires making judgment calls, such as which technique is worth propagating to which model, how wide a hyperparameter search should be, why a model is not showing gains, or how to detect and resolve failures. Those decisions still required significant human bandwidth, which prevented us from scaling further and from reaching a state where all techniques reached all applicable models within a few weeks of being proven.

That is where AI agents come in.

Scaling Technique Propagation With AI Agents

Our technique propagation system is built around three capabilities:

  • Discovery: Keep a live view of which techniques have been proven and estimate how well each might transfer to generate a prioritized set of technique-model candidates, ranked by expected impact.
  • Generalization: Generalize a proven technique so it works on models it was not originally designed for. For models built from shared templates, a technique is generalized once per template and reaches every model built from it. Beyond what templates cover, each model needs its own adaptation, which is where the deepest technical reasoning happens.
  • Adoption: Turn validated adaptations into shipped models, many at a time: launching experiments, managing asynchronous multi-day training runs, monitoring convergence, diagnosing and recovering from failures, and assembling proposals that can land.

Today, AI agents supercharge all the above capabilities by taking on the judgment-heavy, non-deterministic decision making and bringing deep intelligence to the system. They combine LLM-based reasoning with specialized ML tooling to handle the work of deciding which adaptations to try, diagnosing why something failed and automatically mitigating it, navigating hyperparameter search spaces efficiently, and managing capacity across hundreds of concurrent jobs. The agents share a common knowledge base, an accumulated record of prior training runs, model architectures, and technique outcomes, so they build on what has already been learned rather than starting from scratch.

How Agents Speed Up Discovery

Discovery answers two questions: What proven techniques exist, and how applicable are they to each model in the model fleet? Until recently, domain experts answered both, working through the assessments one model at a time. They tracked research and results across the organization, spotted the techniques worth propagating, and relied on their domain knowledge to judge applicability.

Agents aren’t constrained by the same knowledge or engineering bandwidth limitations as domain experts. Instead of relying on what any one expert knows, they draw on the shared knowledge base, and they make assessments across the entire model fleet at once rather than one model at a time. They systematically identify which proven techniques exist, estimate their transferability across the model fleet, and produce prioritized technique lists ranked by expected impact. Engineers now only have to review the agents’ assessments and make a decision from there.

How Agents Make Generalization More Computationally Efficient

Generalization is the process of re-implementing a technique proven on one model so it applies to models with different architectures, feature representations, training data, and serving constraints. The core idea usually transfers, but the implementation almost never does. The customization needed depends on the technique and the target model, ranging from retuning hyperparameters, to adapting features to what the target model already consumes or resizing the architecture to fit its inference budget, to redesigning the technique outright. Deciding what a given model needs, and how far to go, is a judgment call.

Depending on whether a model is built from standardized templates or customized individually, generalization comes in two flavors, and agents assist with both:

  • Template generalization: For models built from standardized templates, agents assist with building, evaluating, and improving the templates themselves. They propose template optimization hypotheses from proven techniques, launch experiments across representative model sets, evaluate results, diagnose failures, and iterate through multiple rounds, helping manage the multi-day loops that template development requires. Validating a technique once at the template level costs a fraction of the compute of adapting each model separately.
  • Bespoke generalization: For our highest-revenue models, where we still customize a technique for each model, agents progressively learn while working alongside ML engineers during the initial application of a technique to a small number of models. As the engineer makes adaptation decisions such as adjusting configurations, tuning hyperparameters, or resolving failures, the agent tracks every change and outcome, encoding what works, what doesn’t, and which decisions are model-specific versus generalizable. With that grounding, the agent proposes and tests adaptations for the remaining models, with the engineer reviewing and steering rather than driving each one.

Drawing on millions of prior training runs and each target model’s own properties, agents start from the configurations most likely to work, use the results of each round of training runs to narrow the hyperparameter search space for the next, and decide which experiments are worth continuing and which to stop early. As a result, when measured across select technique-model combinations, we have seen a median 4x reduction in training compute.

How Agents Accelerate Adoption

At the adoption stage, agents ship generalized techniques model-by-model. They launch experiments, manage asynchronous multi-day training runs, fine-tune each model, monitor convergence, recover from failures, and assemble validated proposals.

Fine-tuning happens differently depending on how the technique arrived. For techniques applied individually, agents help find the best configuration of technique bundles for that particular model. For models built from a shared template, an auto-research loop searches on top of the template, tuning each model for the gains the shared configuration alone does not deliver.

When failures occur, whether from an infrastructure issue, training divergence, or a data pipeline error, integrated debugging and recovery diagnose the root cause and apply targeted fixes or retries.

Running hundreds of these workflows at once raises the question of which jobs get priority, and which runs are worth continuing or stopping early. Getting the most out of a fixed compute budget is a global optimization problem, and it is where we are currently investing. Agents monitor concurrent training jobs, rank them by revenue importance, technique potential, and deadline proximity, and reclaim capacity from stalled or low-value runs, so GPUs stay pointed at the highest-value work rather than sitting idle or queued behind lower-priority experiments.

In the past, an engineer had to watch each run, triage every failure by hand, and restart it, which capped each of them at a handful of models. Now they can keep oversight at the decision points, approving plans and setting priorities at a 3x greater productivity (each engineer can now handle 3x more technique-model adaptations), compressing the time from a proven technique to a shipped model.

How We Evaluate Agent-Driven Propagation

Techniques propagated by agents are evaluated the same way as those propagated by engineers. A technique has to show improved offline metrics for predictive performance, such as normalized entropy (NE), while not regressing on key guardrails like training or inference cost. It then has to show a statistically significant win in online A/B testing before it can be shipped.

But a single evaluation at the end comes too late to steer an agent working across stages over days. Each stage produces a different artifact, so each needs its own metrics. This is how we validate what agents are doing.

Discovery: We measure the precision and recall of the technique-model candidates agents select. For a given technique, precision is the share of selected models where the technique ultimately ships, and recall is the share of all viable models for that technique that agents surfaced. Recall matters more here, since a model missed at this stage never gets a second chance; precision acts as a guardrail against spending compute on techniques that will not work.

Generalization: We evaluate techniques generalized by agents across a wide range of models to ensure each delivers gains beyond the model it was originally proven on. We first test every generalized technique on scaled-down versions of models, screening technique-model adaptations broadly while keeping compute usage efficient. Then techniques that pass are evaluated on a representative set of full-size models, where they must improve NE and meet every guardrail metric before moving to adoption.

Adoption: At this stage, we continue to evaluate correctness with the same predictive performance and guardrail metrics as before. But adoption is also the most operationally heavy stage, with experiments that run for days, so we evaluate agent productivity as well. Two metrics matter most: the number of human interventions needed to complete an experiment, which shows how much engineering time each experiment still takes, and the percentage of issues agents diagnose and mitigate on their own.

Humans continue to be key stakeholders throughout the propagation process, reviewing key decisions, confirming judgment calls, and ultimately approving what ships.

Making Agent-Driven Propagation the Standard at Meta

Given our early results, we are ramping agent-driven workflows to be the primary modality for technique propagation across the model fleet.

Today it can take over a year for every proven technique to reach every applicable model. We’re aiming to reduce that time down to three months. Achieving that means pushing agent-driven workflows toward 5x higher end-to-end throughput, so propagation keeps pace with innovation rather than trailing it.

To get there we are continuing to invest in the intelligence of the agents themselves, improving the quality of generalization, capacity efficiency, and execution through self-evolving learning, where agents refine their own strategies based on accumulated outcomes rather than relying solely on human-provided heuristics.

Propagating techniques across the models is one component of a larger vision. We are agentifying every aspect of the end-to-end model development lifecycle across the ranking AI space, from exploration and hypothesis generation to propagation, experimentation, and production launch. These agents represent the scaling layer of this system, ensuring that every proven innovation reaches its full potential across the model fleet.

Acknowledgements

Babak Behsaz, Anuj Bindal, Wenlin Chen, Jae-Woo Choi, Kapil Dontula, Jason Flaks, Ali Gowani, Umut Gunduz, Varun Jalan, Annapurna Kala, Anika Karpurapu, Santanu Kolay, Sundeep Mallela, JP Owed, Rudresh Rajnikant Panchal, Sandeep Pandey, Dhiraj Parashar, Ray Qin, Shah Rahman, Munaf Sahaf, Alex Sandrovskii, Matt Steiner, Vivienne Sung, Ritwik Tewari, Alireza Vahdatpour, Jacky Wang, Hitesh Yalamanchili, Fan Yang, Shuting Zhao, Wenhan Zhao, and Peng Zhong.

Tech aistartupenterprise

Anthropic IPO raises over $81 billion in largest offering on record, topping SpaceX

Anthropic raised $81.3 billion in a historic IPO, reaching a $1.5 trillion valuation as the firm races against OpenAI for enterprise dominance.

Summary

What: Anthropic sold 980 million shares at $83 per share, exceeding the $70-$78 range. Major backers including Amazon, Google, Nvidia, and AMD participated in a $26 billion side investment. The firm reported $33.24 billion in revenue for the first nine months of 2026, a 1,200% year-over-year increase, despite a $104 billion net loss attributed to convertible note valuations.
Why it matters: The valuation underscores the intense capital intensity of AI model training and the ongoing scramble among cloud hyperscalers to secure ecosystem control through massive equity investments in labs like Anthropic.

Deep Dive

  • Anthropic IPO priced at $83, raising $81.3 billion.
  • Current market cap stands at $1.5 trillion.
  • Ticker symbol 'ANT' begins trading on Nasdaq.
  • Revenue grew 1,200% YOY to $33.24 billion in nine months.
  • $104 billion net loss is largely accounting-based from convertible notes.
  • Strategic investors include Google, Amazon, Microsoft, Nvidia, and AMD.
  • CEO Dario Amodei emphasizes safety-focused commercialization.
  • Follow-on IPO expected from OpenAI in 2027.

Decoder

  • Fully diluted market cap: The total value of a company assuming all possible shares, including those from options, warrants, and convertible debt, are exercised.
  • Convertible notes: Debt instruments that automatically convert into equity shares under specific conditions, often creating significant non-cash fluctuations on balance sheets as the company valuation changes.

Original Article

  • Anthropic priced its IPO at $83 per share, above the expected range.
  • The AI company is expected to begin trading on the Nasdaq under the ticker symbol "ANT" on Thursday.
  • Anthropic upsized its offering and sold about 980 million shares, raising $81.3 billion.

Anthropic priced its IPO at $83 per share on Wednesday, above the expected range, setting the stage for the Claude creator's eagerly awaited Nasdaq listing and a historic moment for the artificial intelligence industry.

The company, along with its seven co-founders, upsized the offering, selling about 980 million shares, according to a press release. That brings the amount raised to $81.3 billion, surpassing SpaceX, which held a record IPO in June. Elon Musk's company raised $75 billion initially and a total of $85.7 billion after underwriters exercised their overallotment.

Anthropic's fully diluted market cap sits at around $1.5 trillion. The stock is expected to begin trading on the Nasdaq on Thursday under the ticker symbol "ANT."

The listing is a major test for the AI industry, which has experienced a set of recent shocks, including a dramatic backlash that was felt at the polls in the midterm elections and last week's ouster of Nvidia CEO Jensen Huang. The market was already jittery on concerns that rising interest rates will make debt unaffordable for many data center developers and neoclouds.

After publicly unveiling its prospectus in October, Anthropic updated the document last week with an expected price range between $70 and $78 per share. The company had been planning to sell 825 million shares.

Tech's biggest companies have significant exposure to Anthropic, as an investor, partner or customer. Amazon and Google both own stakes valued at over $100 billion, and a group of tech companies, including Google, Microsoft, Nvidia and Advanced Micro Devices agreed to collectively invest $26 billion at the IPO price. Anthropic, meanwhile, is a buyer of costly systems from Nvidia, Google, Amazon and AMD.

"I think if we do this right, we can create an age of miracles where humanity is able to solve problems that have eluded us for millennia," Anthropic CEO Dario Amodei said in Anthropic's roadshow video. "We have to make sure that all the risks, all the ways that things can go wrong with this technology, we very carefully address those risks as we bring the benefits and as we have a viable business at the same time."

Amodei co-founded Anthropic in 2021 alongside a handful of other researchers less than six years ago, after the group collectively defected from OpenAI. The company is best known for developing a family of AI models called Claude, and it primarily sells its products and services to other businesses.

According to the latest prospectus, each co-founder is selling 3.38 million shares for total proceeds of $1.96 billion.

Anthropic has been racing to maintain an edge over OpenAI and Google in the enterprise market, and it experienced a period of explosive growth in 2026, driven largely by the popularity of its AI coding tool, Claude Code. OpenAI has confidentially filed for an IPO and has said a debut is likely in 2027.

For the nine months ended Sept. 30, Anthropic said, it generated $33.24 billion in revenue, up roughly 1,200% from the same period last year, according to its prospectus. The company reported a $104 billion net loss during the nine-month period, though most of that was due to the change in fair value of convertible notes and derivative liabilities. Anthropic lost $25.1 billion over the same stretch in 2025, the filing said.

Anthropic said in an amended filing that its run-rate revenue was roughly $81 billion at the end of October, up $10 billion from the previous month.

The company has faced plenty of challenges during its meteoric rise over its positions on safety, regulation and national security, leading to two high-profile disputes with the U.S. government this year. Its prospectus included more than 90 pages of risk factors for investors to consider ahead of its IPO.

"Our aim is to help humankind chart a safe course through this technological evolution, open new frontiers of discovery, and bring forth an age of miracles," Anthropic's co-founders wrote in the company's prospectus. "Everyone who owns our stock, whether an institution or an individual, becomes part of that effort."

Tech aillm

Google launches Gemini 4 Neon on Gemini, Antigravity, and APIs

Google launched Gemini 4 Neon, a mid-tier model with a 1M-token context window, outperforming Claude Opus 5.5 on CursorBench at lower cost.

Summary

What: Gemini 4 Neon is priced at $3/million input tokens and $15/million output tokens. It is positioned between the Carbon and Hydrogen models, focusing on balancing high-level reasoning with fast, agentic execution.
Why it matters: Google's rapid release cadence shows a strategy of flooding the market with tiered specialized models that compete on both performance and 'cost-per-task' metrics against Anthropic's Claude lineup.
Takeaway: If you are running agentic workflows, test Gemini 4 Neon as an orchestrator to manage parallel subagents, as it is currently optimized for these high-frequency, complex tasks.

Decoder

  • CursorBench: A coding-specific benchmark used to evaluate how effectively AI models can complete software engineering tasks within an IDE.
  • Context window: The maximum amount of information (tokens) an AI model can process at once.
  • Agentic workflow: The use of AI agents to perform a series of autonomous steps to reach a goal, rather than just generating a single response.

Original Article

Google has released Gemini 4 Neon, a new member of the Gemini 4 family that brings frontier-level intelligence with fast end-to-end task completion for software engineering, knowledge work, and science.

Introducing Gemini 4 Neon! Pushing the frontier across domains and punching above its model class in a meaningful way. To me, Neon feels like the right balance of intelligence, speed, and usability. Available now across @GoogleAIStudio, the API, and more!

It is rolling out now in the Gemini API paid tier in Google AI Studio and Android Studio, in Gemini for business through the API and model dropdown, in Google Antigravity for paid Google AI Pro and Ultra subscribers, and in the Gemini app for Pro and Ultra subscribers. Eligible members of the Fairwind Program will start getting a cyber defense version over the next few days.

Neon sits between Carbon, built for the hardest long-horizon projects, and Hydrogen, built for fast everyday execution. It costs $3 per million input tokens and $15 per million output tokens, with cached input at $0.15, and works with spreadsheets, PDFs, charts, audio and video in a 1 million-token context window.

Four thinking levels let teams trade intelligence for token spend, and at the default high level Google says it costs 32% less per task than Carbon. In Antigravity, Neon can act as an orchestrator directing parallel Hydrogen subagents, while in the Gemini app it now powers Tasks and deeper analysis.

Gemini 4 Neon is #1 on Cursorbench. Yet another Google Cursorbench mog.

Google reports a score of 61 on the Artificial Analysis Intelligence Index at xhigh, ranking third behind larger, slower models, along with first place on the Artificial Analysis Coding Agent Index at 58.6 and second on the Vals Index at 70.9%. In Google's comparison table, Neon scores 65.4% on CursorBench 4.1 against 58.1% for Claude Opus 5.5, plus 65.2% on Terminal-Bench 4.1 and 39.0% on SWE-sweep inside Antigravity.

Google DeepMind's Gemini 4 Neon debuts at #2 on the Vals Index (70.9%), 0.4 points behind Claude Fable 5.2 at less than half the cost per task. It also takes #1 on our Finance and Legal Indexes, Tax Agent and Legal Research.

Arena says Neon debuts second on its new Agent Arena Index with 1,336 points from about 4,200 real-world agent sessions, ahead of Carbon, Hydrogen and Argon, at a median cost of $2.82 per task. That is 53% less than Claude Opus 5.5, which Neon outranks. In the Text Arena, Google now holds the top three spots, with Neon third at 1,518.

Big news: Gemini 4 Neon (High) is the best @GoogleDeepmind model on the Agent Arena Index, ranking #2 overall and reshaping the Pareto frontier! With 1336 pts based on 4.2k real-world agentic sessions from Arena’s global community, it surpassed: #4 Carbon (High): 1303 pts.

The company says Neon keeps Carbon-level protections against severe misuse and prompt injection while declining far less legitimate work, and that it recorded its lowest fabrication rate yet in internal Antigravity testing. Google pitches it as frontier-level reasoning for complex, high-frequency workflows, delivered faster and at lower cost than its largest models.

Google continues to accelerate its release cadence with Gemini 4 Neon, delivering a small Intelligence gain over Gemini 4 Carbon at a ~17% lower Cost per Task @GoogleDeepMind has released Gemini 4 Neon, its fourth model in just seven weeks. Neon (xhigh) scores 61 on the…

I think this is a huge win for Google. A model listed below Carbon's standard price now outscores Claude Opus 5.5 on CursorBench, beats Carbon on Agent Arena, and lands near the top of the Artificial Analysis index.

Data enterprise

Data Contracts

Data contracts treat datasets like APIs, using formal schemas and quality assertions to guarantee trust for both humans and AI agents.

Summary

What: The Open Data Contract Standard (ODCS 3.2) provides a YAML-based machine-readable format to define schema, quality thresholds, and service levels, enabling autonomous systems to safely consume data.
Why it matters: As AI agents increasingly interact with enterprise data, they need explicit metadata guarantees to avoid making 'confidently wrong' decisions caused by ambiguous data.

Deep Dive

  • ODCS 3.2 includes 'AI Context' sections specifically for agent guidance.
  • Contracts are provider-driven, versioned, and machine-verifiable.
  • Quality rules (e.g., SQL-based row count assertions) prevent 'select *' style ambiguity.
  • Integration with Git workflows and CI/CD pipelines allows automated verification of SLAs.
  • Semantic linking to ontologies reduces metadata duplication and ensures consistency across datasets.

Decoder

  • Data Contract: A formal agreement or specification describing the schema, semantics, and quality guarantees of a dataset.
  • ODCS: Open Data Contract Standard; a standardized YAML format managed by the Linux Foundation's Bitol project for defining data contracts.

Original Article

Full article content is not available for inline reading.

Read the original article →

Design devopsaienterprise

AI Sped up the Build: How Can Accessibility Testing Keep Up?

While AI has accelerated the software build process, accessibility testing is lagging, leading to a 10.1% increase in detected errors per web page.

Summary

What: Level Access reports that only 30% of teams see AI gains in QA, recommending that human judgment be embedded via annotated Figma handoffs and CI/CD-gated accessibility checks.
Why it matters: Teams are using AI to generate code faster than their testing infrastructure can validate, resulting in a 'two-speed' workflow that creates technical and accessibility debt.
Takeaway: Implement accessibility-focused CI/CD gates (e.g., eslint-plugin-jsx-a11y) and require regression tests for every AI-drafted fix.

Deep Dive

  • Development speed has outpaced QA validation workflows.
  • Organizations that succeed in accessibility do not rely on AI tools alone, but on mature culture and training.
  • Accessibility checks should move into the design phase using annotation toolkits.
  • Automate sweeps across pages using engines like axe-core or Equal Access.
  • Human judgment is still required for UX interaction testing that automated tools miss.
  • Every accessibility fix should be accompanied by a regression test to prevent recurrence.

Decoder

  • Shift left: Moving testing and validation activities earlier in the development lifecycle.
  • VPAT (Voluntary Product Accessibility Template): A document that explains how a product meets the Revised Section 508 accessibility standards.
  • Regression test: Testing to ensure that new code changes have not broken existing functionality.

Original Article

AI has sped up how teams design and build, but quality assurance (QA) testing hasn’t kept pace, and the web may be getting less accessible. Drawing on new research, Andrew Chung explains what separates the teams whose accessibility efforts are keeping up, and how to embed human judgment into AI-enabled workflows without slowing delivery.

Lately, I’ve been thinking and writing a lot about what AI is doing to product development, and what that means for accessibility. The thing that has my wheels turning is a finding from Level Access’s 2026 State of Digital Accessibility Report. Basically: AI is helping us hit fast-forward on the build, but testing practices haven’t kept up.

We asked more than 2,500 professionals where they noticed AI was speeding up their work in the SDLC. Most said they noticed gains in planning (58%), design (61%), and development (51%). But QA and testing lagged behind: Only 30% said AI had sped up that stage.

These results point to a two-speed workflow. AI has turbocharged design, planning, and development, while checking and validation are still running at a very different pace. This means a lot of teams are likely racing through the build, then being forced to hit the brakes the moment someone has to answer a pretty fundamental question: Is this thing actually accessible?

Accessibility has historically been treated as a QA bottleneck, and AI is pushing far more work into it, faster. If your team has already shifted left on accessibility, you’re off to a good start. But AI has reshuffled the workflow, so even proactive teams need to work out where those early checks belong now.

This matters because right now, the web is moving in the wrong direction. WebAIM’s latest scan of the top million home pages found that automatically detected errors per home page rose 10.1% in a year, from 51 to 56.1 per page. WebAIM cited AI-assisted coding as one possible contributing factor.

So how do we get validation out of first gear? How do we build human judgment into the workflow as AI keeps pushing the pace?

AI Isn’t The Biggest Differentiator

We looked at the organizations that are improving across every accessibility metric they track (a group we call the “improvers”) to find out what they’re doing differently.

Here’s what stood out: AI adoption made the smallest difference of anything we measured. Improvers use AI at a similar rate to everyone else we surveyed. Their edge shows up in the maturity of their surrounding accessibility practices — things like training, communication, and a culture of accessibility.

A quick caveat: This is survey data, so it only shows correlation, and mature programs may simply be better at tracking and reporting their wins. Even so, this finding was hard to ignore.

And it got even more interesting. Professionals in mature accessibility programs were nearly six times as likely to say AI helps them prioritize issues. They were also nearly three times as likely to say it helps them tackle accessibility more proactively in development.

In other words, AI works best as an amplifier of a strong program. With context, testing, environments, and guardrails in place, agents can take on a large share of the work from drafting through to operations, and much of the time lost to waiting and handoffs goes away. People stay responsible for deciding what to build and for approving what ships.

So let me ask you: When it comes to accessibility, where does human judgment sit in your workflow today?

Not sure? Here’s a quick way to find out.

Pick a feature you shipped recently and trace it from the first Figma frame to production. Mark every moment a person decided whether it would work for someone using a keyboard, a screen reader, or their browser at 400% zoom.

How many marks did you get? If most of them cluster at the end of creation, you’re likely heading to one of two places: You’ll either ship accessibility barriers or spend the time you saved upstream fixing them later, when they’re harder and costlier to fix.

Here’s how to avoid both outcomes by building the right accessibility checks and judgment calls into the work your team is already doing.

Build The Judgment Calls Into Your Workflow

As AI takes on more work, people need to stay involved at three points: finding issues, fixing them, and documenting the evidence. Each one plugs into a step your team already takes, like a handoff, a pull request, or a review, so nothing new gets added to the timeline, and accessibility keeps pace with the work that’s in motion.

1. Find: Catch Issues While The Work Is Still Warm

Context fades fast. Put the first judgment checkpoints as close to the creation work as you can:

  • Start at the handoff. Spell out focus order, accessible names, states, heading structure, and what gets announced when something changes or goes wrong. If you leave anything vague, the model fills the gap with its own defaults. Then, put it where the model reads it: your design system components, rules files (Cursor rules, AGENTS.md, Copilot instructions), and prompt templates, not only a spec document. For designers, free annotation kits make this concrete. GitHub’s Annotation Toolkit offers Figma components for marking headings, landmarks, focus order, and keyboard behaviour on the canvas, so the intent travels with the file instead of living in someone’s head.
  • Gate the pull request. Run checks in your CI/CD pipeline and at the pull request. Let them block or warn on a merge. Compare against a baseline so you only review changes. (This is the automated half of the gate: The human half of this same checkpoint shows up again under Fix). Most teams already have the tooling in place for this, but what is new is volume. AI-assisted pull requests arrive faster than reviewers can read them, so the automated gate matters more, not less. In React projects, eslint-plugin-jsx-a11y flags issues before commit, while Pa11y and Lighthouse CI scan builds for new errors. Level CI also brings accessibility testing into the CI/CD workflow, including pre-merge detection, delta findings, quality gates, and fix recommendations in pull requests.
  • Let automation do the sweep, send the judgment calls to people. Run automated checks across pages, screens, and documents for broad, repeatable coverage. For the sweep, QualWeb, for example, checks pages against the W3C’s ACT rules. Running your tests across several engines, like axe-core and Equal Access, can be a good idea, as one may help you catch things that the other misses. But, have people assess usability: A dropdown can pass automated checks while its submenu remains inaccessible to keyboard users.
  • Give every check an owner. For example, designers specify focus, errors, and states. Developers run a keyboard pass and a screen reader smoke test on custom components. (Note: Screen reader testing is harder in practice than it may seem at first, so your team might need an introductory training). UX or QA navigates the full journey. Put accessibility metrics in acceptance criteria and the definition of done, and back it with component-level tests because “everyone owns it” has a funny way of turning into “nobody did it.” When teams decide, in advance, who is responsible for each check, they create the clarity and communication that our data shows sets the organizations improving accessibility apart from those stuck fighting ever-growing backlogs.

2. Fix: Act Before The Context Goes Cold

Found the issue? Great. Fix it while it’s fresh. When issues end up as tickets, make sure the context travels with them. They should carry the element, the repro, the related WCAG criterion, a suggested fix, and the PR link, so context doesn’t leak.

  • Move the guidance to the work. Whether the fix happens in the editor, the design file, or the component library, the answers should be right there. If your team uses an AI coding assistant, an MCP server can pull accessibility findings and fix guidance straight into it so developers can work through issues without leaving their editor.
  • Let AI take the first pass. Use AI to draft, with guardrails. AI coding assistants can propose changes quickly, but they optimize for a passing check, not a correct experience. Give them grounded fix guidance for the specific issue, and treat their output as a draft. Open-source skill sets can help ground that guidance. A good starting point is the accessibility instructions file in the Awesome Copilot collection, which steers Copilot toward accessible patterns. Once you’ve got your draft, re-run the check, then review the semantics and test the behaviour because a green result can come from markup that looks right and isn’t (e.g., role="button" on a div, redundant ARIA, invented alt text). The speed is useful only if verification keeps pace.
  • Review before anything merges. Test the change in context. Did it solve the original problem without breaking anything else? Does the interaction now behave and announce itself as intended? Note: This gate is doing different work than the per-check testing upstream in “Find”: That caught the issue; this work confirms the fix actually holds in context.
  • Work the backlog by impact. Pulling older findings? Start with things that block someone from completing a key journey, like paying a bill or resetting a password. Then tackle the quickest fixes first. Include the component, what went wrong, and the guidance to fix it. Don’t expect someone to reconstruct the story.

3. Prove: Leave A Receipt

The worst time to start gathering evidence is when somebody’s asking for it.

Every check, fix, and judgment call throughout the process described above should ideally leave a trail. A fix isn’t done until something fails if the issue comes back. Ask your AI assistant to write the regression test with the fix and put the finding link and any judgment call in the PR description. That’s the receipt.

A passing test shows a known issue hasn’t returned. It doesn’t show the experience works. For what automation can’t cover, add a short note to the PR: what you tested, with which assistive technology, and any judgment calls you made.

  • Let tooling do the admin. When someone later asks what was tested and who approved it, tooling can assemble the answer from those PRs and tests. We cut VPAT/ACR authoring time by more than 70% this way with the Level Access Reporting Agent, but only because the evidence already existed. Again, the tool compounds a practice. It doesn’t replace one.

Keep The Speed: Move The Judgment With It

AI has given digital creation a speed boost, but broadly speaking, validating the work hasn’t kept pace. Closing that gap isn’t about adopting more AI in more places or abandoning the toolset that helped make your team faster.

According to our data, the opportunity in front of teams is to build the practice around that toolset, so that human judgment is flagged, embedded, and acted on earlier, and more often.

We’ve only scratched the surface of what our data tells us about AI and accessibility. If you’re curious about what else we found, check out the 2026 State of Digital Accessibility Report. There’s plenty more to unpack.

AI llm

Why is Gemini 4 Carbon taking so long?

Benchmarking suggests Gemini 4 Carbon struggles with bug-fixing speed because it performs redundant code audits and re-reads files instead of making efficient edits.

Summary

What: On a private evaluation, Carbon took nearly an hour to fix bugs that Claude Opus 5.5 and GPT-6 Astra resolved in minutes. Analysis found Carbon makes 7x more steps and 16x more input processing than Astra.
Why it matters: This highlights the trade-off between model thoroughness and operational speed; models trained to be 'safe' or 'cautious' may suffer from over-analysis that degrades developer productivity.

Deep Dive

  • Inference lag: 16-30% of the slowness comes from raw model speed compared to Astra.
  • Workload volume: Carbon performs excessive code auditing beyond the bug scope.
  • Mechanical inefficiency: Carbon makes fewer tool calls per step and frequently re-reads already processed lines.
  • Over-analysis: The model often closes loopholes not identified in the bug report.
  • Check-in validation: Injected check-ins ('do you have enough info?') reduced Carbon's runtime from 37 to 28 minutes.

Decoder

  • Inference: The process of running a trained machine learning model on new data to make a prediction or generate content.
  • Harness: A set of tools or an environment used to test the performance and accuracy of a model against a dataset.

Original Article

Why is Gemini 4 Carbon taking so long?

While benchmarking Gemini 4 Carbon on one of our private evals, we found something surprising: it spent close to an hour completing tasks that routinely took Opus and Astra only a few minutes.

Turns out we weren't alone in noticing this.

I don't really know how to properly emphasize this. Gemini 4 Carbon is unacceptably slow in real world usage.

To find out why, we traced every step of Carbon's runs and quantified what contributes to the slowness.

The Task

In each task, the agent gets a codebase from just before a bug was fixed, along with a report that describes the bug only by its symptoms. Its job is to diagnose the bug and fix it, without making any unrelated changes.

Much of the task's difficulty comes from engineering judgment rather than raw intelligence: tracing the user's symptoms to the right code path, ruling out rival explanations, putting the fix in the right place, and knowing when to stop.

Slow inference, or more work?

The first (and easiest) factor to separate out was inference speed: queueing at the provider, network latency, prompt processing and generation speed. Together, these set how long each step takes.

Slower inference accounts for part of the gap: 16–30% of Carbon’s extra time compared with Astra, and 45–49% compared with Opus. The rest comes from longer trajectories. Carbon simply does more work per task, as the step counts, tool calls and tokens below show.

Carbon takes about seven times as many steps as Astra, and eleven times as many actions such as reading a file or running a command. It writes seven times as much and, because every step re-sends a longer and longer conversation, it processes more than sixteen times as much input.

Ruling out the obvious

Before looking inside the runs, we checked two simpler explanations.

  • The harness. We also ran Carbon inside two other coding agents, opencode and mini-SWE-agent, and saw no meaningful difference.
  • Mismatched reasoning levels. Effort settings aren't standardized across providers, so Carbon's "high" may sit closer to the other models' maximum settings, and the fairer comparison might have been Carbon on low. But on low, Carbon often failed to produce a fix at all: it went in circles, re-reading code it had already read instead of making the fix.

Reading the traces

We labelled every step of the Astra and Carbon runs by what it was for, and then counted how many steps went to each kind of work.

Half of Carbon’s steps went into work the ticket never asked for:

  • Auditing code beyond the bug. Once it had found the cause, Carbon kept widening its search, checking every related path through the system and auditing code the fix never needed to touch.
  • Closing loopholes the ticket had already ruled out. Carbon defended against cases the ticket's facts had already excluded, hardening the code against problems nobody had reported.

In this sample trial, both models identified the cause early, Astra within a minute and Carbon within about six. Astra had its fix written three minutes later; Carbon didn't write any code for another 25 minutes.

Carbon might not have been sure it had the cause (a knowledge gap), or it might have known and kept going anyway (a general habit, learned from training that rewards right answers more than it penalises extra steps). To tell them apart, we re-ran one of the trials in a modified harness that automatically injects the same check-in every five turns: "do you already have enough to make the fix?"

With check-ins, Carbon finished in 28 minutes instead of 37, and the wait between naming the cause and editing shrank from 25 minutes to about 10. This implies that the slowness seems to come from how Carbon behaves, not what it knows.

Carbon's necessary work is also slower

Even within the steps the fix needed, we found some additional low-hanging fruit: Carbon got less done with each step, and it kept re-reading code it had already seen.

Astra made more than two tool calls per step, often reading several files at once — Carbon, on the other hand, made about one, usually reading a single file. Carbon also re-read far more: 39% of the lines it read were ones it had already seen, against 7% for Astra. We estimate that these two "mechanical" inefficiencies account for roughly 25% of Carbon's excess runtime.

Conclusion

On difficult bug-fixing tasks, Carbon took close to an hour where Opus and Astra took minutes. We traced that gap to three sources:

  • Slower inference. Each step takes longer, which explains 16–30% of the gap against Astra and about half against Opus.
  • Unnecessary work. About half of Carbon's steps went on work the tickets never asked for: auditing code the fix didn't need and closing loopholes the ticket had already ruled out.
  • Mechanical inefficiencies. Fewer tool calls per step and frequent re-reading slow Carbon down; we estimate that fixing them alone would cut its runtime by roughly a quarter.
AI devops

Why Antigravity Eats Weekly Quota Fast - and What I Measured

Google Antigravity wipes prompt caches after 5 minutes of idle time, forcing users to pay for full context re-ingestion frequently.

Summary

What: Researcher Aastha Subedi discovered that a background keep-alive ping can prevent cache eviction, saving up to 8.9x on token costs in large coding sessions.
Why it matters: This reveals how opaque infrastructure costs—like cache TTL (Time To Live)—can significantly impact the economics of using frontier AI models for long-duration coding tasks.
Takeaway: If using the CLI, consider using custom keep-alive scripts to ping your session every 4 minutes and 30 seconds to avoid the 5-minute cache cliff.

Deep Dive

  • Cache behavior: Implicit caching is discarded after 285 seconds of inactivity.
  • Cost impact: Re-ingesting 150k context tokens after a miss is drastically more expensive than a warm cache hit.
  • Binary findings: Google's internal code has a dormant 'keepalive.go' engine that performs 1-token pings to keep the cache warm.
  • Methodology: The researcher used binary patching on the Antigravity CLI to unlock the native keep-alive engine.
  • Efficiency: A ping cycle saves 29-36% of effective token costs on standard sessions.

Decoder

  • TTL (Time To Live): A setting that determines how long data remains in a cache before being deleted or refreshed.
  • Implicit caching: A system where the provider automatically attempts to reuse cached tokens from the beginning of a prompt if the sequence matches previous requests.
  • MCP (Model Context Protocol): An open standard for connecting AI agents to data sources and tools.

Original Article

Why Antigravity Eats Weekly Quota Fast - and What I Measured

Gemini 4 Hydrogen, Gemini 4 Argon, and hy4-flash via OpenCode used for the binary reverse engineering, empirical cache probing, and keep-alive tooling.

Introduction

Greetings! If you use Google Antigravity (agy) with the big frontier models, you have probably noticed how fast your weekly quota disappears during normal coding sessions.

My suspicion was simple: a short prompt-cache lifetime. When you are coding with an agent, you don’t send messages every 10 seconds. You wait for a response, read the diff, run a test, think for 5 minutes, and then send your next prompt. If the prompt cache expires during that 5-minute pause, your next message has to re-ingest the entire conversation history at full price.

Instead of just assuming that was true, I decided to actually test it and look inside the Antigravity binaries to see how caching works under the hood. What started as a quick TTL check turned into disassembling a 193 MB Go binary, discovering a dormant keep-alive engine that Google already wrote, binary-searching the exact eviction cliff down to a 15-second window, testing whether /btw side-questions can keep the cache warm, and finally unlocking Google’s built-in zero-trajectory keep-alive engine on a live 6-minute run.

1. Background: Implicit Caching & The Idle Tax

To understand why pauses matter, let’s look at how Gemini models handle context in Antigravity.

Every turn in an agentic coding session carries a massive prefix: the system prompt, tool schemas, connected MCP servers, skill definitions, and all previous turns. On Gemini 4 models, Antigravity relies exclusively on implicit caching. Unlike explicit caching (where you manually place cache breakpoints and pay for a guaranteed storage lease), implicit caching is an automatic, best-effort prefix match on Google’s backend.

When your request hits the implicit cache, cached tokens (cache_read_tokens) get a 90% discount compared to regular uncached input_tokens. When the cache misses, you pay 100% on the entire prefix.

Google does not publish a fixed TTL for implicit caching. If that TTL is shorter than a typical code-review pause, interactive coding turns into a worst-case workload.

2. What the Binary Says

Before running live probes, I inspected the local Antigravity installation on macOS (arm64): the desktop app (/Applications/Antigravity.app, v2.33.0), its core Go agent binary (language_server), and the standalone CLI (~/.gemini/bin/agy, v1.5.11 / 1.5.12) across isolated CLI runs.

2.1 Telemetry Buckets Give Away the 5-Minute Cliff

Inspecting the Go symbol table in language_server immediately confirmed that Antigravity tracks cumulative context through CumulativePromptHandler and buckets turn gaps into two telemetry categories: lt_5m (less than 5 minutes) and ge_5m (5 minutes or more). That alone was a strong clue that 5 minutes is the magic number.

2.2 Google Already Built a Keep-Alive Engine

Digging deeper, I found a file path in the binary’s symbol table: modelapiccpa/keepalive.go. Disassembling its functions (keepAlivePings, beforeRequest, scheduleNextPingLocked, ping, and trimLastBlock) revealed that Google already built an automatic background prompt-cache keep-alive mechanism.

Here is how their internal keep-alive works:

  1. Zero-Trajectory Pollution: When a turn finishes (onRequestDone), the client schedules a background timer. When the timer fires, it clones the last request protobuf, calls trimLastBlock to replace the final prompt block with a single period ("."), sets max_output_tokens = 1, tags the request with "prompt_cache_keep_alive": "true", and sends it in the background. When the 1-token response comes back, it throws it away so it never pollutes your conversation history.
  2. Exact Hardcoded Timers:
    • Ping interval: Hardcoded in scheduleNextPingLocked to 4 min 30 s (270s).
    • Staleness cutoff: Hardcoded in ping to 4 min 45 s (285s). If the timer wakes up more than 4m 45s after the last turn (e.g., after laptop sleep), it aborts the ping because it knows the server cache is already dead.

Why do we still lose the cache every 5 minutes? Two gates in the binary stop it from running:

  • Gate A (keepAlivePings): Locked behind server-side Mendel experiment flags (enable-prompt-cache-keep-alive and prompt_cache_keep_alive_max_pings) that aren’t exposed in settings.json or Antigravity hooks.
  • Gate B (beforeRequest): Checks the internal model provider enum (0x5 or 0xa) and currently restricts background pings to explicit-cache provider enums (like Claude), completely skipping Gemini models.

3. Experimental Setup: Measuring Cache Hits

Since account-level quota percentages are noisy (other background agents share the same quota pool), I used cache_read_tokens from agy --input-format stream-json --output-format stream-json as the primary ground-truth signal.

At the end of every turn, agy emits a DONE event for agent_response with three numbers:

  • input_tokens (T_uncached): Tokens billed at full price.
  • cache_read_tokens (T_cached): Prefix tokens served from the implicit cache.
  • output_tokens: Generated response tokens.
Observed Signal What It Means
Large cache_read_tokens (~14,770), small input_tokens (~2,150) Cache Hit - prefix served from cache, only tail billed at full price.
cache_read_tokens = 0, large input_tokens (~16,820+) Cache Miss - full prefix re-ingested from scratch.

4. What I Measured

4.1 Separate CLI Processes Don’t Share the Cache

First, I tried running two separate one-shot agy -p --conversation <same-id> commands back-to-back. Two things stood out immediately:

  1. Even on a brand-new conversation with a 5-word prompt, Turn 1 sends 16,816 tokens (system prompt, tool declarations, MCP servers, and skills).
  2. In the same process, Turn 2 hits the cache for 14,762 tokens, leaving only 2,152 uncached tokens. Across separate one-shot agy -p processes, cache_read is always 0 because one-shot mode re-initializes the step timestamp at step 0, breaking prefix continuity.

4.2 The 8-Minute Idle Test (With vs. Without a Ping)

I tested an 8-minute idle gap with no activity, and compared it against an 8-minute window with a single keep-alive ping at +4 minutes. This proved that without a ping, waiting 8 minutes forces Turn 2 to pay full price, and hitting the implicit cache resets its TTL timer.

4.3 Binary Search for the Exact Expiry Boundary

To find the exact cliff where the cache dies, I ran a binary search across idle intervals. The boundary is between 4 min 45 s and 5 min 00 s. That matches both my initial 5-minute estimate and the 4 min 45 s (285s) staleness cutoff hardcoded inside Google’s keepalive.go.

5. Cost Analysis & Scaling Math

Since Gemini gives a 90% discount on cached tokens, I calculated the effective token cost (C) of any turn by weighting cache_read_tokens at 0.1x: C = T_uncached + 0.1 * T_cached.

Even on an empty conversation with just the 14.8k base prefix, one well-timed ping saves 29-36% savings. In a 150k-token session, pausing for 5 minutes costs you 133,065 extra effective tokens on your very next message.

6. The /btw Experiment: Can Side-Questions Keep the Cache Warm?

Sending a normal user message as a keep-alive in the CLI has one downside: each ping adds a user and assistant turn to your trajectory. Antigravity has a /btw slash command that lets you ask a side question in a forked thread. My tests showed /btw does keep the main cache warm, but it is expensive: it costs ~4.9x a normal warm ping and ~26% more than just accepting a cache miss.

7. Unlocking Google’s Built-In Engine & Live Verification

I built a verification and binary-patching script to unlock Google’s internal keepalive.go engine. By patching the prologue and provider branch, I confirmed that the background streamGenerateContent ping fired automatically and refreshed the backend cache without adding a single character to the conversation history.

8. Wrapping Up & Practical Takeaways

  1. The 5-minute cache cliff is real: Both empirical binary search (4m 45s - 5m 00s) and Google’s own hardcoded 285s (4m 45s) cutoff confirm that a 5-minute pause wipes your prompt cache.
  2. A 4m 30s keep-alive ping works, if you cap it: Refreshing the cache before expiry saves 30% to 88% of effective tokens across a pause.
  3. Google’s built-in keepalive.go engine works on Gemini: Once its Mendel flag and provider-enum gates are unlocked, Antigravity’s native background ping keeps Gemini caches warm across 6+ minute pauses with zero trajectory growth.
  4. Trim your baseline prefix: Disabling unused MCP servers and plugins shrinks every cold turn and cache miss across the board.
AI enterprise

Switching LLMs mid-conversation is a ski-rental problem

Routing coding agents between models requires solving the 'ski-rental problem' to determine if the cost of switching models is offset by subsequent savings.

Summary

What: Edgee's Agent Gateway uses a ski-rental algorithm to decide when to switch a running session to a cheaper model, balancing the cost of a full context rewrite against potential token savings.
Why it matters: As LLM usage shifts from one-off queries to long-lived coding agents, the cost of moving context between models becomes a major factor in enterprise AI architecture.
Takeaway: If running a fleet of coding agents, consider auditing the cost-benefit of model switching using Edgee's routing and replay tools.

Deep Dive

  • Routing strategy: Difficulty tiers route tasks, but switching policy manages the cost of cache reloads.
  • The ski-rental analogy: Buying (switching) is worthwhile only if the expected savings from renting (staying on a cheaper model) exceed the initial switch premium.
  • Confidence gating: Upgrades are prioritized by task difficulty, while downgrades are treated as economic decisions.
  • Decay mechanisms: The system prevents 'getting stuck' on an expensive model by decaying rent totals over time.
  • Hindsight optimization: Replaying traffic data allows organizations to compare their current spend against a theoretical optimum.

Decoder

  • Ski-rental problem: A classic mathematical problem where one must decide whether to rent equipment or buy it, without knowing how long the equipment will be needed.
  • Competitive analysis: A method for evaluating online algorithms based on their worst-case performance relative to an optimal offline algorithm.

Original Article

Full article content is not available for inline reading.

Read the original article →

AI hardware

Advancing chip design with OpenAI models

OpenAI used its own models to optimize chip designs, resulting in a 10% to 13% reduction in circuit area for its Jalapeño AI chip.

Summary

What: The collaboration also extended to AMD, yielding up to 14% improvements in area and power efficiency on flagship GPU layouts by using AI for floorplanning and logic optimization.
Why it matters: This demonstrates a shift toward using generative models for physical synthesis and electronic design automation (EDA), potentially shortening hardware development cycles.

Decoder

  • Circuit area: The physical space occupied by logic components on a silicon die; smaller areas usually lead to lower costs and higher manufacturing yields.
  • Floorplanning: The process of arranging hardware components and wires on a chip to balance performance, power, and space.

Original Article

Design changes proposed by OpenAI's models cut the circuit area of key parts of its Jalapeño AI chip by an estimated 10% to 13%. With AMD, the same approach delivered up to 14% improvements on AMD's flagship GPU designs.

AI web

Context API extracts full context from any web page

Perplexity released a Context API that extracts clean Markdown and metadata from up to 10 URLs simultaneously for agent-based workflows.

Summary

What: The API fetches content from web pages using Perplexity's index or live requests, filters boilerplate like ads and cookie banners, and returns relevant passages with source metadata for $1 per 1,000 URLs.
Why it matters: Developers are moving toward RAG (Retrieval-Augmented Generation) pipelines that demand higher precision and cleaner data than standard web scraping, shifting the burden of content processing from the model to the data retrieval layer.
Takeaway: Use the Context API to feed clean, formatted text into your LLM agents by providing a list of URLs to the `/v1/context` endpoint.

Deep Dive

  • Provides clean Markdown, HTML, and metadata from target URLs
  • Supports batch processing for up to 10 URLs
  • Offers 'freshness' control via max_age_seconds
  • Includes semantic snippet extraction based on query relevance
  • Uses block-level scoring to filter out navigation and boilerplate
  • Priced at $1 per 1,000 successful URL fetches

Decoder

  • RAG (Retrieval-Augmented Generation): A technique where an AI model retrieves external, up-to-date data (like search results or documentation) to improve the quality of its response, rather than relying solely on training data.
  • Boilerplate: Standardized, repetitive HTML code found on websites—such as navigation menus, sidebars, and footers—that is often useless for an AI agent trying to parse page content.

Original Article

When someone asks a chatbot a question, an AI agent may need to read several web pages to answer it. Standard search results often return only snippets. Fetching a page directly can return raw HTML, which is full of navigation, cookie banners, and ads. Agents need the page’s context in a format a model can use, while developers need a way to control how fresh that context must be.

Today we’re launching the Perplexity Context API, which reads up to 10 URLs and returns clean markdown, HTML, links, and query-based snippets for each page. The information comes from Perplexity's vast web index or a live fetch. Agents can specify the freshness of each request, and validate the source of each result.

Context API supports a variety of formats

Agents can initiate a request by providing a list of URLs and specifying the output formats. The API returns a result for each URL in the same order.

Context API supports a variety of response formats:

  • Markdown: The page content as clean Markdown, ready to place in a model’s context.
  • HTML: The page's HTML, for applications that run their own parsing.
  • Links: The links on the page as absolute URLs, without duplicates and in page order so an agent can decide where to go next.
  • Snippets: The passages of the page most relevant to a query provided, within the token limit set by the developer for each page.

Context API selects passages from each page that are relevant to the query, rather than generating a summary. As a result, the model receives the page’s original wording, but only the selected passages, so there is less text to process.

Every successful result also includes metadata such as the title, description, language, author, and published date, plus the page's Open Graph tags. To build the Markdown, the Context API splits a page into blocks and a model scores each block as main content or boilerplate. Only the content blocks are kept.

Essential for tasks that need the full picture

Finding a relevant page isn’t always enough to complete a job. Using Context API, agents can retrieve the content they need from selected URLs to complete complex tasks.

  • Implementing an API integration: A search result may identify the right documentation without including the required parameters, authentication instructions, or error cases. Context API can help a coding agent retrieve the documentation and API references to write an integration based on those details.
  • Comparing current prices: A listed price may depend on usage limits, billing terms, or eligibility conditions that are missing from a search excerpt. An agent can request a live fetch of selected pricing pages and read those conditions before making a comparison.
  • Answering policy questions: A return-policy excerpt may state the standard return window but omit exceptions for particular products or regions. A support agent can retrieve the policy page so its answer accounts for those exceptions.
  • Researching across multiple sources: A search excerpt may surface a finding without the methodology, qualifications, or surrounding argument. A research agent can retrieve the selected articles and reports, then compare the evidence rather than relying on excerpts alone.

Control freshness and handle URLs reliably

By default, the Context API first checks Perplexity’s web index for a copy of the page fetched within the last two days. If there isn't one, it fetches the page live. Developers can change max_age_seconds to 0 to always read the live pages, for prices, scores, and breaking news. For reference material that rarely changes, they can raise it. Set cache_only to true for workloads that should never trigger a live request.

Each result records whether the content came from a stored copy or a live fetch, and when it was fetched.

URLs in a request are fetched in parallel, each with its own time budget and its own status. One slow or broken page doesn’t fail the others. The status indicates what happened with each URL, so an agent can retry only the pages that timed out and keep the rest.

Context API returns usable, complete content

We tested the Context API against Firecrawl, Exa, Parallel, Keenable and Context.dev on thousands of URLs sampled from real agent fetch requests. The set covers 715 sites and includes government and academic sources and non-English pages. A separate judge model then scored the outputs without knowing which provider produced each one.

The chart measures performance on three criteria:

  • Usable: The share of URLs that came back with the page's real content, not an error page or an empty result.
  • Fact recall: The judge collects the key facts found on a page across all providers, then checks which of them each output contains. A failed fetch scores zero.
  • Content precision: The share of returned text that is page content, not cookie notices, navigation, or ads, averaged over all URLs. A failed fetch scores zero.

In this evaluation the Context API returned usable content for 92.3% of URLs, recovered 87.9% of the key facts, and scored 80.3% precision on content precision.

Pricing

Context API costs $1 per 1,000 URLs fetched. Developers pay for each URL that returns ok. URLs that fail aren’t billed.

Getting started

curl --request POST https://api.perplexity.ai/v1/context \  --header "Authorization: Bearer $PERPLEXITY_API_KEY" \  --header "Content-Type: application/json" \  --data '{  "urls": ["https://info.cern.ch/hypertext/WWW/TheProject.html"],  "formats": ["markdown"]  }'

Each result comes back with the page's Markdown, the passages that match the query, the page metadata, and a status. Check the status of each result before using its content.

Read the Context API docs or see the API reference.

AI infrastructuredevops

Introducing Model Factory

Prime Intellect launched Model Factory, a control plane for training and deploying AI models that integrates RL and SFT in a single loop.

Summary

What: The platform provides a unified interface for reinforcement learning, supervised fine-tuning, and inference, allowing companies to own their model development lifecycle rather than relying on external APIs.
Why it matters: This signals a trend where enterprises move from 'renting' AI via APIs to building 'model factories' to maintain proprietary control over their AI weights and performance data.
Takeaway: If you are managing long-running AI experiments, investigate the Model Factory CLI to centralize your compute orchestration and node management.

Deep Dive

  • Integrates training, inference, and evaluation into one control plane
  • Supports reinforcement learning (RL) and supervised fine-tuning (SFT)
  • Features automated health checks and node replacement for long-running experiments
  • Offers on-demand GPU usage or dedicated Slurm/Kubernetes deployments
  • Uses Prime Traces to feedback production performance data into future training runs

Decoder

  • RL (Reinforcement Learning): A training method where an AI learns by trial and error, receiving rewards or penalties based on its performance in an environment.
  • SFT (Supervised Fine-Tuning): The process of taking a pre-trained base model and further training it on a specific, curated dataset to improve performance on certain tasks.
  • Slurm: A popular, open-source cluster management and job scheduling system for high-performance computing (HPC) environments.

Original Article

Introducing Model Factory

Today we introduce Model Factory: the loop that frontier labs run on. Now, any company can train, deploy, and continuously improve models in production.

Model Factory brings reinforcement learning (RL), supervised fine-tuning (SFT), pre-training, and inference together on one control plane.

There are two ways to get started:

  • On-demand hosted training: submit a training configuration and run on managed GPUs, billed per GPU-hour.
  • Dedicated Model Factory deployments: work with our team on reserved capacity and deeper control, with managed training and inference alongside direct Slurm and Kubernetes access.

We’re already deploying Model Factory for teams working on finance automation, computer use, scientific discovery, chip design, and more.

Own your model factory. Own your intelligence.

Every company should own its model factory

Frontier labs have an advantage that extends beyond any single model: they own the entire process of building and improving it. They train a model, deploy it, study how it performs, and use what they learn to train the next one. The steps are closely connected, and the data and knowledge stay in-house.

We believe every company should have this edge. Teams working in scientific discovery, chip design, finance, and other specialized domains know their problems in far greater detail than any general-purpose model provider. They should be able to build on that advantage by training and deploying models on their own tasks and data.

A team that wants better AI for its own domain has two paths:

  • Rent the model. This is the fastest way to start, but entails three costs. First, actions are limited beyond prompting: because you do not own the model weights, you cannot train the model on your own reward signal. Second, you give away information to the provider, which enables them to train a model based on your prompts and data and take over in your domain. Third, the provider can unilaterally change or retire the model version your product depends on with little warning.
  • Own the model. This is the only option where you own the weights, data, and lessons from production. It also means you can train, deploy, and improve your own model. Most teams start with an open-weights model and fine-tune or run RL on it.

Until recently, owning the model factory has been possible for only those capable of assembling GPUs, developing a custom training framework, maintaining inference at scale, and managing large-scale sandboxes infrastructure. Today, we’ve lowered the bar to entry and made it possible for any team to train a model: Model Factory is a lab in a box.

Model Factory allows researchers and engineers to focus on the experiments and products only they can build, instead of grappling with complex infrastructure. Compared to its predecessor Lab, this platform goes much deeper and lets you fully train models end-to-end, be it pre-training, mid-training, supervised fine-tuning, or large scale Reinforcement Learning. Training connects directly to large-scale production inference, one-click model deployments, trace capture, metrics, sandboxes, and custom agent harnesses, so the whole loop runs in one system.

Unified training, inference, environments, evals and sandboxes

When you train an agent with reinforcement learning, it first attempts tasks and receives a score for how well it performed. An orchestrator batches these scored attempts and sends them to a trainer to update the model's weights. The updated model then attempts more tasks, and the cycle repeats. Each round brings together inference to generate responses, sandboxes to execute code and tool calls, and environments to score the results.

Model Factory runs training, inference, sandboxes, and orchestration from one control pane. Researchers define the tasks, rewards, and training recipe without having to assemble the underlying infrastructure themselves.

A researcher might start with an open-source model and a set of coding tasks, then inspect its attempts to understand where it falls short. Does it find the right files and run the tests? Does it solve the problem or work around it? Those observations shape the next experiment: researchers might implement better demonstrations for SFT, a different reward signal for RL, or harder tasks.

During a run, researchers can track reward scores and inspect the agent's individual attempts. If a coding agent's score improves, they can read its patches and test results to check whether it is actually fixing more bugs. They can then evaluate checkpoints on a separate set of tasks to see whether the improvement holds beyond the tasks used for training.

1. Train

Train agents with reinforcement learning

First, choose your model from our catalogue of open-source models, or bring your own. Then, define your tasks and environment your agent will train in. The environment provides the tools and context the agent needs to attempt each task, along with a reward signal that scores its performance.

To run training with these environments, Model Factory integrates verifiers, the Environments Hub, and Harbor support. For agents that write code or use tools, it also natively integrates up to tens of thousands of concurrent microVM sandboxes into the run.

Supervised fine-tuning

Hosted supervised fine-tuning (SFT) trains a model on examples of the behavior you want, such as successful task completions, demonstrations, or curated responses from your domain.

You can use the fine-tuned model directly, or use it as the starting point for an RL run, where the model improves through practice and feedback from an environment.

Pre-training and mid-training

Beyond RL and fine-tuning, Model Factory supports pre-training new models and the continued training of existing base models. Run Model Factory on demand, or use a dedicated deployment for deeper infrastructure control and customization.

2. Deploy

Launch an inference endpoint from the dashboard with one click, whether with Model Factory on demand or within a dedicated Model Factory deployment.

Training and inference share the same infrastructure. The model you developed can become an endpoint for your application, a source of synthetic data, or the model behind your next evaluation run.

3. Improve

Prime Traces enable you to turn production traces into your next training run. For any given task attempt, you can record the tools an agent called, the path it took through a task, and where it failed.

These failures can inform the next environment: determine which examples belong in the next run, how to score them, and whether the resulting model is ready to deploy. And the Deploy → Improve → Train cycle continues.

Dedicated Model Factory

At scale, hardware failures are part of training. Model Factory offers health checks, automatic node replacement, and recovery from the latest checkpoint for long-running experiments. This can be accessed through the prime factory CLI, which gives teams one interface to manage compute and move GPUs between different workloads.

Some experiments require changes beyond the training configuration, whether this is a new architecture, a different objective, or a custom rollout strategy. Dedicated deployments allow researchers to modify the underlying frameworks and work directly with the cluster through Slurm and Kubernetes. This way, teams can run managed training and inference workloads alongside direct cluster access, and change the system where their work requires it.

Talk to our team

Looking for a dedicated Model Factory deployment? Tell us about your models, workloads, and compute needs. We’ll help you get started on your GPUs or ours.

AI infrastructure

Anthropic's compute spending is increasing by 4x per year, outpacing OpenAI's 3x

Anthropic’s compute spending reached an annualized $40 billion in Q3 2026, growing at a 4x annual rate that outpaces OpenAI’s 3x growth.

Summary

What: Anthropic spent nearly $10 billion on compute and infrastructure in Q3 2026, with approximately half paid to SpaceX, while OpenAI is projected to spend $50 billion total in 2026.
Why it matters: The massive shift in capital toward compute providers like SpaceX suggests that the 'compute-compute-compute' race is increasingly becoming a capital-expenditure-heavy infrastructure war rather than purely a software development effort.

Deep Dive

  • Spending growth: Anthropic's annualized spend rose from $0.43B in 2023 to $39.45B in Q3 2026.
  • Cloud dependencies: Both companies rely on major cloud providers (Amazon, Google, Microsoft) and SpaceX for compute.
  • SpaceX impact: SpaceX received about $5B from Anthropic in Q3 2026, comprising roughly 34.5% of SpaceX's total revenue for that period.
  • Cost of revenue vs. R&D: Anthropic spends a shrinking percentage of its compute budget on customer inference (26% in 2026) compared to internal R&D.
  • Future commitments: Anthropic has contractually committed to $447.5 billion in compute spending through 2030.

Original Article

Anthropic spent nearly $10 billion on compute and infrastructure in the third quarter of 2026, or close to $40 billion on an annualized basis, up from just $433 million in 2023. By comparison, OpenAI appears to have roughly tripled its compute spending annually and forecasts similar growth for 2026, though data for OpenAI is sparser.

Most of Anthropic and OpenAI’s compute spending goes to cloud partners such as Amazon, Google, Microsoft, and SpaceX, which rent compute capacity to Anthropic and OpenAI. Much of Anthropic’s compute spend growth this year is attributable to SpaceX: Anthropic paid SpaceX around $5 billion for compute in the third quarter of 2026, roughly half of Anthropic’s total compute spending that quarter.

Learn more about this graph

We compile reports and disclosures about Anthropic and OpenAI’s spending on compute over time, and convert these figures into spending run rates to estimate how quickly each company has ramped up their compute spending over the past several years.

Data

For Anthropic, we use compute spending figures from the company’s Form S-1, filed in advance of its IPO. The S-1 disclosed “compute and infrastructure” spending for the seven calendar quarters from 2025 through Q3 2026, as well as annual totals in 2023 and 2024. It also disclosed spending commitments of $447.5 billion, “substantially all” related to compute and infrastructure, from September 2026 through the end of 2030, or around $100 billion per year.

For OpenAI, we source compute spend from media reports. OpenAI President Greg Brockman testified in May 2026 that the company expects to spend $50 billion on compute this year, but we do not have any non-forecasted figures for OpenAI in 2026.

Because these spending figures are a mix of quarterly and annual data, they need to be converted to annualized run rates for direct comparison.

Analysis

All of Anthropic and OpenAI’s compute spend figures are period-based totals for a given year or quarter. To compare a mix of annual and quarterly data, we convert them into estimated annualized spending rates. For quarterly numbers, this means multiplying the spending amount by four. We also need to attribute the spending rates for each period to an exact date. We assign each spending estimate a date by assuming that spending grew at a steady exponential rate between reporting periods.

We then fit growth rates to these points via a log-linear regression. We derive 90% confidence intervals analytically using standard errors.

Most of Anthropic’s compute is used internally for R&D and other purposes, not to serve external customers. Anthropic’s S-1 discloses its customer inference spending as “cost of revenue,” which is “substantially all” compute:

  • In 2025, Anthropic’s cost of revenue was $2.773 billion, or 38% of its $7.326 billion in total compute spending.
  • In the first 9 months of 2026, this share decreased to just 26%, or $4.812 billion in cost of revenue against $18.8 billion in compute spend.

By comparison, media reports indicate that around 50% of OpenAI’s compute spending was allocated to customer inference in 2025, up from roughly one-third in 2024.

In terms of future growth, Anthropic has also already contractually committed to $447.5 billion in future compute spending through 2030 per its S-1. This would be roughly another doubling from the current rate, so it is not clear that Anthropic’s future compute spending will grow at anywhere near the 4x annual growth of the past three years. Meanwhile, OpenAI plans to spend around $750 billion on compute over the same period.

Assumptions and limitations

  • OpenAI’s compute spending figures come from media reporting, not from disclosed financial statements, so there is more uncertainty in the underlying accuracy and interpretation of the numbers.
  • Dollar spending cannot be straightforwardly converted into other metrics of compute capacity, such as floating point operations per second or watts of power.
  • While it is safe to assume that a large majority of these companies’ compute spending is for capacity directly supporting AI research and the training and inference of AI models, we do not know exactly how this spending breaks down between AI accelerator capacity, dedicated CPU capacity related to training or inference, or general cloud compute capacity for other parts of the technology stack.
AI agents

Introducing Stitch Loop: A new way to build and evolve products

Google Labs introduced Stitch Loop, a product agent that monitors codebase metrics to autonomously suggest and prepare pull requests for continuous maintenance.

Summary

What: Stitch Loop integrates with GitHub and product telemetry to manage 'evergreen' loops that target security, latency, and accessibility improvements, requiring human approval for all changes.
Why it matters: This represents the 'post-ship' frontier for coding agents, shifting from just building features to long-term lifecycle management and technical debt mitigation.
Takeaway: Join the waitlist at stitch.google.com/loop/waitlist to experiment with autonomous maintenance loops.

Deep Dive

  • Integration: Connects to GitHub, logs, and user behavior data via 180+ integrations or custom MCP servers.
  • Workflow: Agents scan for improvements, offer solutions with trade-off analysis, build code in a cloud sandbox, and open PRs.
  • Learning: The system reflects on live performance metrics after changes are merged to refine future suggestions.
  • Safety: Includes specialized loops (e.g., CodeMender for security) and manual approval gating for all code changes.
  • Flexibility: Works with existing coding agents like Google Antigravity to power continuous improvement.

Decoder

  • MCP: Model Context Protocol; an open standard that allows AI agents to securely connect to data sources, tools, and codebases.

Original Article

Introducing Stitch Loop: A new way to build and evolve products

As part of a new direction for Stitch, we’re introducing a new experiment, Stitch Loop: a long-running product agent that connects to your codebase and live metrics to continuously improve what you’ve shipped.

Coding agents let you build and ship new features fast, but their job ends the moment your pull request merges. Once code hits production, the real work starts: patching vulnerabilities, speeding up checkout, and diagnosing signup drop-offs buried in noisy feedback. For lean teams, balancing post-launch maintenance with continuous improvement is a constant challenge, yet it’s also what drives some of the world’s most successful products.

Today, we are introducing Stitch Loop, a long-running product agent from Google Labs that connects to your codebase and live metrics, finds what needs fixing, and keeps working 24/7 on your product until your goals are met.

Millions of designers, developers, and founders already use Stitch to turn ideas into working interfaces in minutes. Together, Stitch and Stitch Loop are steps toward our broader ambition for Stitch: creating agents to help lean teams tackle the hardest parts of creating great products from ideation through continuous optimization.

See how it works

You start by connecting GitHub and your product context (logs, user behavior, feedback, etc) with over 180 integrations, custom MCP servers, or local CLI uploads. Grounded in that context, Stitch Loop runs evergreen loops to continuously optimize toward the measurable outcomes you care about. You get three default loops out of the box and can add your own anytime. Each loop runs through four steps:

  1. Suggestions: Stitch Loop surfaces opportunities to make progress towards your goals, grounded in evidence from your product.
  2. Solutions: Every suggestion comes with one or more solutions— each with tradeoffs and scoping, along with visual design options where applicable.
  3. Build: Once you choose a direction, Stitch Loop writes the code in an isolated cloud sandbox and opens a GitHub pull request for your approval. When relevant, the PR will contain screenshots and videos of the work Loop did.
  4. Reflect: Stitch Loop monitors live product data as it works toward your goal, learning from every positive or negative result to sharpen the next round of insights. Once the goal is met, it keeps watching in case the metric slips.

You always have the final call. Nothing merges until you review the PR.

Automate codebase security

Stitch Loop comes with built-in loops for cybersecurity, latency, and accessibility, plus the ability to create custom loops like improving checkout conversion.

Security is often the hardest gap to cover for lean teams shipping quickly. Stitch Loop includes a dedicated security loop that pairs Gemini 4 Carbon's cyber security capabilities with CodeMender, Google DeepMind's autonomous agent that improves code security. Together, they scan your codebase for security vulnerabilities before they become incidents. Stitch Loop flags each issue it finds with evidence and opens a PR with a proposed fix for your review.

Use it with your agents and existing workflows

You can use Stitch Loop as a service layer for coding agents, like Google Antigravity, or bring it into the places where your team already works, like Slack.

Whatever coding agent you prefer can pull persistent product context from Stitch Loop via the Stitch CLI and MCP to power mixed-model setups and fully autonomous improvements in your existing workflow.

In Slack, just use @stitch to get daily insight digests and create new loops.

Join the waitlist

The Stitch Loop waitlist opens today for all users, globally, with eligible Google AI Ultra users getting priority access. Join at stitch.google.com/loop/waitlist and share your feedback in the Google Labs Discord.

Tech infrastructureresearch

Unblockable communication with gravity

Researchers demonstrated a communication protocol using gravitational signal modulation, which remains unblockable by traditional electromagnetic screening methods.

Summary

What: The study proposes a method where binary messages are encoded by the physical displacement of a mass, with signal detection performed by a portable, off-the-shelf gravimeter. This bypasses the vulnerabilities of radio frequency or light-based signals that can be shielded or jammed.
Why it matters: While currently limited in data rate, this proves the viability of an entirely new physical layer for communications in environments where electromagnetic transparency is impossible.

Deep Dive

  • Current communications (Wi-Fi, cellular, radio) rely on electromagnetic waves that are easily intercepted or blocked.
  • Gravity offers a communication medium that is physically impossible to screen using standard Faraday cages.
  • Protocol involves mechanical modulation of a local mass to create measurable gravity fluctuations.
  • Receivers use commercial, hand-held gravimeters to decode signal patterns.
  • The proof-of-concept establishes binary transmission over physical distance without electromagnetic signatures.

Decoder

  • Gravimeter: A precision instrument used to measure the local gravitational field of the Earth.
  • Electromagnetic screening: The practice of blocking electromagnetic signals using conductive materials (Faraday cages).

Original Article

All modern wireless communication technologies are based on electromagnetism, which is readily susceptible to screening and blocking. Gravity is a viable platform for practically unblockable communication. This study proposes and implements a wireless communication protocol where a broadcaster encodes a binary message by moving a mass, and a receiver detects the resulting gravitational signal with an off-the-shelf, hand-held gravimeter.

Tech aihardwareenterprise

Hardware Is Software

Modern hardware engineering is shifting from manual calculation to software-defined algorithms, allowing small teams to achieve radical cost and design efficiencies.

Summary

What: Tomas Pueyo argues that traditional hardware design is stuck in an era of 'manual arithmetic' and that AI-driven algorithmic design—as used by companies like Boom Supersonic—is rendering legacy processes obsolete. The piece highlights how this shift, combined with humanoid robotics, could reduce total manufacturing costs across the value chain by up to 75%.
Why it matters: The industry is moving toward a model where R&D and physical manufacturing are entirely automated by generative AI, drastically lowering the barrier to entry for building complex, physics-based products.

Deep Dive

  • Hardware engineering is currently inefficient, often relying on manual spreadsheets instead of robust, version-controlled software.
  • Design should be treated as an algorithm: a repeatable, testable software system.
  • AI enables smaller teams to design complex parts like turbines, drastically reducing design time and team size.
  • The 'Idiot Index' highlights the disparity between raw material costs and final product prices, suggesting massive room for cost optimization via automation.
  • Total cost reduction across the value chain (including labor and R&D) is projected to reach ~75% as AI replaces white-collar design and blue-collar physical labor.

Decoder

  • Idiot Index: A metric coined by Elon Musk defined as the ratio of an end product's cost to the cost of its raw materials; a high index indicates significant waste in design and manufacturing processes.
  • Inference: The process of running a trained machine learning model to generate predictions or content.

Original Article

Hardware Is Software

1. Hardware Becomes Software

A US company is trying to bring back supersonic civilian flight, and to make their airplanes faster and cheaper than the Concorde.

You can’t call Boom a simple hardware engineering company. They’re taking on one of the hardest engineering challenges out there. So I was surprised when its founder CEO, Blake Scholl, said this:

12 years ago I founded Boom, as a software engineer doing hardware for the first time.

More than a decade in, the most insane realization is that software is the key to reaccelerating hardware engineering. But in a way that I don’t think is widely understood or implemented, even in the burgeoning hard tech community.

Most hardware engineering is actually software engineering in disguise. It’s spreadsheet “code,” engineering calculations done as one-offs. Eg, wing structural loads in, spar sizing design out. Thermal loads in, air conditioning system sizing out.

Everything is a calculation, and calculation is software. But these calculations are done essentially by hand, as if we are doing arithmetic but have not yet discovered algebra.

Hardware engineers have baby software, built in spreadsheets, the kind of crappy software I wrote as a kid before I understood architecture, unit tests, APIs, version control, and everything else that makes modern software good.

Our airplanes and engines are built with the software sophistication of a script kiddie.

So what we tell our engineers: don’t design the hardware, design the *algorithm* for designing the hardware. And take the algorithm seriously—as an algorithm and as a first-class engineered software system.

Never design a piece of hardware, such that you couldn’t redesign it tomorrow with a different set of assumptions.

This all sounds obvious, yet our experience at Boom is that it changes everything.

Ten years ago we couldn’t afford to build much software. We had a small team—and there were few software engineers with the curiosity, brilliance, and vision required to learn hardware engineering.

But now AI changes the equation. Now everyone can code. The software engineers define the architecture. The hardware people bring the physics and engineering know-how.

We have a turbomachinery design tool that lets one engineer do in realtime what previously took 100 engineers six months. Another tool auto-generates 65% of entire aircraft structure. I’m sure we’ll figure out the other 35% too. Eventually these should not be multiple tools, but one integrated physics model of a complete vehicle, airframe and powertrain.

The results speak for themselves. A boomless supersonic airplane built by 50. A full scale supersonic turbine made by 150. And with this approach, I don’t think we’ll need that many more people to build and certify a supersonic airliner.

You don’t need a big team to build big things—not when everyone on the team is a software engineer.

NASA proved this is the case: In this 2022 paper, they used AI to design industrial parts, and they were 40% cheaper, 66% lighter, 85% faster to design, and more robust than human expert-designed parts. That was NASA in 2022, before AI got really good. Imagine putting a tool that’s one million times better in the hands of every manufacturer.

2. Hardware = AI

So what happens when you don’t need a big hardware team when everybody is a software engineer, but AI replaces software engineers?

Here’s a side project of Casey Handmer, founder of Terraform (I’m an investor):

According to him, he asked Claude:

Design a printed circuit board that can use radar to detect my heart rate.

Claude designed the circuit and physical layout, the firmware, the software… I assume Casey sent the files to a board printing and assembly company, and got it back for a couple hundred bucks. Here’s what the device can do:

It can do range, angle, motion frequency. It can tell if I'm typing and guess what it is (not perfect). It can tell if I'm speaking but not what I'm saying.

The only physical step in all of this was the board manufacture and assembly, but that’s already a commodity, because a lot of that process is automated today—and more will probably be.

So what happens when you push this thinking further? Casey has yet another prediction, after Jensen Huang stepped down from NVIDIA:

Nvidia is cooked either way. GPU [Graphics Processing Unit, the computers NVIDIA sells] design and CUDA [the software that lets programs use the GPU efficiently] were insurmountable moats 12 months ago, now a Fable-class model [Claude, basically] can independently rebuild both for <$1m token spend.

Indeed, NVIDIA doesn’t manufacture its GPUs, TSMC does. NVIDIA just designs them and adds their software. People have four trillion reasons to reverse engineer that software and design. Google was already doing this a decade ago, and it’s been using AI to do it for years. That’s how they got their competing TPUs. Now, everybody can do it.

3. Cutting Intelligence Costs in Manufacturing

You can see where this is going: R&D costs will soon be eliminated from manufacturing. Depending on the industry, they account for ~5-20% of a manufacturing company’s revenue. But AI won’t just reduce those; it will go well beyond. A lot of manufacturing costs go to designing requirements, documenting, detailed engineering, experimentation, measurement, certification, qualification—all tasks that can be automated. And of course, better design also means cheaper designs, so the cost of parts, transportation, and energy will also shrink with more AI.

Here’s one way to think about it. Look at solar panel costs over time:

For 50 years, we’ve been shrinking their costs by 12% per year, learning how to produce more with less. If the learning pace was faster (thanks to AI), we might have been able to reduce costs by 20% year on year, and we would have gotten to the same point 20 years earlier. At a learning pace of 30% per year, we would have gotten there 32 years earlier.

As the panels got cheaper, they also got better though! So cost, materials, efficiency, and quality all improved together.

What’s the limit to this improvement?

4. The Idiot Index

When Elon Musk wanted to buy a ballistic missile from the Russians to go to Mars, they quoted him such a ridiculous price that on the plane home, he took his computer out, opened a spreadsheet, started calculating the cost of the raw materials, and realized they were just 2% of the total price of a rocket.

He started calling that the Idiot Index: If a thing costs much more than its raw materials, it means there’s some idiot here that couldn’t make it cheaper, that there was too much waste caused by human intelligence—or lack thereof.

So how much could he reduce rocket costs? Falcon Heavy reduced costs by 98%. Starship will further reduce costs by 93%, for a total of ~99.9%.

Of course, space companies were not very efficient—in fact, many like Boeing are just a jobs program at best, and a grift at worst—so maybe they’re an outlier. But the logic stands: An intelligent designer can cut costs so radically that raw materials become a much bigger part of the end product.

But one thing is to eliminate white-collar workers, and the other is blue-collar ones. Much harder, right?

5. Blue-Collar Too

Another chunk of human costs is not the R&D and other white-collar jobs, but blue-collar ones. Together, they account for 25% of manufacturing companies’ costs. Will AI reduce their cost too though? Yes.

The only reason blue collar work still exists is because we haven’t yet been able to use AI to automate the workers’ movements in a cost-effective way. Many more movements could be automated with better AI design of replacement machines. Industry experts definitely think physical AI will transform many industries.

But some human physical skills have been just too hard to automate so far (eg, hands), so that’s what the robot industry is working on. If humanoid robots succeed in the coming years, blue collar work is likely to fall.

I think it will happen in the next 2-5 years. If that sounds pretty aggressive to you, you’ll want to read the upcoming article on the topic.

The article on humanoid robots should come next week

6. Cutting Costs Across the Value Chain

Between blue- and white-collar workers, including contractors, humans account for ~26% of manufacturing companies’ budgets. Manufacturing company A still has to spend on:

  • Parts, components, packaging, and raw materials: ~62%
  • Machinery: ~3%
  • Energy: ~1.8%
  • Maintenance, repairs, waste removal: ~1.5%
  • Land and buildings: ~1.4%

So by far the biggest cost is the parts and components from their providers… Who will also see a reduction in their costs of ~25% (from humans)! And of course, they will become more efficient with parts and raw materials, so that part of costs will be reduced further. Let’s say company A will reduce these 62% costs by 12 percentage points. Combined with the human cost reduction, we’re at ~37%.

And since company A is in a competitive market (as most manufacturing is), this improvement will be competed away, and prices to customers will shrink by 37% on average.

Only that? No! Company A will put pressure on its providers to reduce their prices too! So Provider B will also have a reduction in costs of 37%. And its own providers will also shrink by 37%! If you push this across the entire value chain, you end up with a total cost reduction of 74%!

The remaining 25% you end up paying for is raw materials, energy, and some human work here and there, at each step to keep the AIs and robots improving.

But are energy and mining safe from the AI onslaught? I just looked into mining and based on that, I changed my investments. I’ll cover it in the next (premium) article.

The mining automation article comes this Friday

What will replace these human costs?

Capital.

Manufacturing companies will need to invest in:

  • Intelligence to replace the white-collar workers—so, pay for inference.
  • Intelligence, plus machines and humanoid robots, to replace the blue-collar workers.

This means robot and AI companies will employ people—just not enough, in my opinion, to make up for the jobs they’ll erase.

Takeaways: Manufacturing Moats

People tend to say that hardware is safe from AI, but it isn’t. From what I can gather:

  1. AI can cut ~20%-25% of human costs in every step of the value chain, plus an additional cut on parts and materials needed.
  2. This adds up to ~65-75% of all the costs across the value chain. Not all these costs will be eliminated, as some will be replaced by the cost of capital for inference and robots, so employment in these companies will growth.
  3. AI will attack first management, R&D, and all other intelligence tasks.
  4. Blue collar work will also be automated with AI, and that will dramatically accelerate as humanoid robots become huge, which I’ll study in an upcoming article.
  5. Competition will translate these lower costs into lower prices for customers.
  6. But also higher quality manufactured products!
  7. This will increase the demand for manufactured products.
  8. But here we’re talking about an absolute carnage in the blue- and white-collar manufacturing jobs. I think it’s unlikely that the increase in the volume of sales will outweigh the job destruction.
  9. Raw materials will then take a much bigger share of the cost of manufactured products—improving the idiot index—,which makes mining an extremely important industry to understand in a world of AI. We’ll explore it in the next article.

Is there a limit to this? Well, it’s all a matter of timelines, and there are two schools of thought here.

One thinks intelligence can only take us so far. There are lots of human decision-makers across the board, vested interests, politics, slow adoption… It will take years for humans to learn to harness AI well in manufacturing. Most existing companies won’t do it well, so we’re about to experience a golden age of startups taking over the manufacturing sector by using AI to work more efficiently. But it’s hard to create mining startups. And of course, intelligence is not the same as physical movement. Humanoid robots will take a few years to arrive, and then a few years to ramp up production to get them everywhere. And in any case, manufacturing is not only about intelligence. It hits the real world of atoms. You need to test things, and that takes time and money independently from the intelligence of AIs. According to this school of thought, it might take one or two decades to see a dramatic change in the manufacturing industry.

The other thinks that AI will be able to plow through all these issues. What prevents Anthropic from creating its own manufacturing companies? From buying out the worst managed ones and implementing change at the speed of its agents? What prevents clever Private Equity companies from buying dozens of these companies with the single purpose of firing everybody and replacing them with AIs? Why would there not be any company that automates atoms testing with AI?

This debate boils down to: How much faster will manufacturing productivity improve in the coming years? If the first school wins, it will take 5-20 years for this revolution to take place. If the second school wins, it will be in the next 1-4 years.

Tech clouddatabaseopensource

AWS announces ExtendDB 1.0

AWS released ExtendDB 1.0, an open-source adapter allowing DynamoDB workloads to run on PostgreSQL, SQLite, Cassandra, or MongoDB.

Summary

What: ExtendDB is an Apache 2.0-licensed tool that provides DynamoDB API compatibility for on-premise, edge, and multi-cloud environments. The 1.0 release includes support for multiple database backends and a developer-friendly container image for CI/CD workflows.
Why it matters: This gives AWS a way to keep DynamoDB-based applications within the AWS ecosystem even when customers need to run workloads outside of the public cloud, effectively lowering the barrier to local development and hybrid deployments.
Takeaway: If you are running DynamoDB but need local testing or edge deployment, clone the repository at github.com/aws/extenddb to start running endpoints over SQLite.

Deep Dive

  • ExtendDB allows DynamoDB API parity on heterogeneous backends.
  • Supported backends: PostgreSQL, SQLite, Cassandra, MongoDB.
  • Enables hybrid/multi-cloud or on-premise execution without code refactoring.
  • Includes a developer-focused container (extenddb-dev) for local testing.
  • Released as open source under Apache 2.0.

Decoder

  • DynamoDB API: The proprietary interface used to interact with Amazon's serverless NoSQL database.
  • On-premise: Infrastructure that is physically hosted at an organization's own facility rather than in a public cloud provider.

Original Article

AWS announces ExtendDB 1.0

Today, Amazon Web Services (AWS) announced version 1.0 of ExtendDB, the first release of the open source Amazon DynamoDB-compatible adapter for production use. ExtendDB is fully compatible with the DynamoDB API and runs on a database backend that you choose, so developers and infrastructure teams can run DynamoDB workloads in on-premises data centers, in private or public clouds, and at the edge without rewriting application code.

ExtendDB 1.0 supports four storage backends, PostgreSQL, SQLite, Cassandra, and MongoDB. For local development and continuous integration (CI), the extenddb-dev container image and the @extenddb/dev npm package run a DynamoDB-compatible endpoint over SQLite, so you don’t have to set up an external database.

ExtendDB is maintained by AWS, released under the Apache 2.0 license, and developed in the open on GitHub. To learn more, see the ExtendDB project page. To get started or contribute, visit the GitHub repository.

Tech aistartupstrategy

Scarcity migration

With AI commoditizing execution, the economy is shifting from a 'build-at-all-costs' model to one where taste, judgment, and trust are the primary sources of value.

Summary

What: The author argues that the venture capital gospel of 'execution is all' is obsolete because AI has reduced software production costs to near zero, shifting the scarce resource to niche-finding and brand reputation.
Why it matters: This indicates a fundamental pivot in the startup ecosystem: moats are moving from technical barriers (how well you build) to relational barriers (how much your specific audience trusts you).
Takeaway: Focus your efforts on building long-term trust and domain expertise in a specific niche rather than chasing generalized technical features that can be trivially automated.

Deep Dive

  • Technical execution is now a commodity rather than a moat.
  • The 'Coasean boundary' of the firm is shrinking as coordination costs drop.
  • Niche markets are becoming economically viable due to low production costs.
  • Trust, taste, and reputation remain the only non-compressible, scarce assets.
  • Organizational debt and social friction are the remaining bottlenecks in AI adoption.
  • Traditional startup success metrics (large addressable markets) are being challenged by the 'niche dividend.'

Decoder

  • Coasean boundary: A theory in economics explaining that the size of a firm is defined by where the cost of managing tasks internally is cheaper than buying them on the open market.
  • Endogenous growth: A theory that economic growth is primarily the result of internal processes like human capital and knowledge, rather than external factors.
  • Non-rival goods: Economic resources that are not depleted when one person consumes them, such as software code or ideas.

Original Article

Scarcity migration

Cognitive and creative production is ceasing to be the constraint, and the economy is beginning to reorganise around what remains scarce: taste, judgment, trust, and the willingness to commit to a specific group of people and their specific problems, rather than building for everyone and therefore for no one.

For twenty-odd years, the venture capital gospel was that ideas are cheap and execution is all that matters. As the saying went, a thousand people have your idea in the shower every morning, and the one who wins is the one who can ship it. Paul Graham preached it, and Marc Andreessen built a firm around it. The entire scaffolding of the startup economy rested on the assumption that building things is hard and thinking of things to build is easy. That paradigm is now inverted.

A solo operator with the right tools can now ship a working product in a weekend that would have taken a funded team six months in 2019. Nor are we talking about a toy or prototype. This is a proper thing with authentication, payments, a design system, and deployment.

So the bottleneck has moved. Execution—the part that used to devour the budget, calendar, and occasionally the founder’s marriage—is being compressed into a commodity. What remains scarce is the original perception, the recognition that a specific group of people have a real unmet need, and the taste to solve it in a way that earns trust. The hard part is no longer building. The hard part is knowing what to build, and for whom, and why they should believe in you.

This feels like and perhaps is a seismic shift, but it is not unprecedented. Scarcity has migrated before. In fact, every major economic era can be read as a story about what was scarce, where that scarcity moved, and how long companies and institutions took to respond.

What Galbraith saw

John Kenneth Galbraith published The Affluent Society in 1958 and made an observation that offended almost everyone. In his view, America had solved the production problem. Factories could produce more goods than people naturally wanted, and the economy responded not by easing off but by creating desire.

Advertising existed to create the wants that production then satisfied, in a loop he called the “dependence effect”. The scarcity of goods was over. Scarcity of demand took its place, and an entire industry grew to paper over the gap.

Galbraith followed in 1967 with The New Industrial State, where he described the technostructure: a layer of managers, engineers, planners, and specialists that large firms needed to coordinate the complexity of modern production. The corporation was big because execution was complex. The technostructure existed because no single person could hold the whole machine in their head. Size was not greed or bloat (although it could be both); it was generally a rational organisational response to the difficulty of getting things done at scale.

What AI is doing to cognitive and creative production now mirrors what postwar industry did to physical goods. Traditional constraints are dissolving. And just as Galbraith’s America had to reckon with an economy organised around a scarcity that no longer existed, we must reckon with an economy organised around the difficulty of execution at a moment when execution is becoming trivially cheap.

The economics of the flip

Ronald Coase asked in 1937 why firms exist at all, given that markets are supposed to allocate resources efficiently. His answer was transaction costs. It is expensive to find suppliers, negotiate contracts, monitor quality, and enforce agreements, so firms bring those functions inside their walls, where hierarchy can manage them more cheaply. The boundary of the firm sits where the cost of doing one more thing internally equals the cost of buying it on the market.

AI is driving a sledgehammer through those transaction costs. Code generation, design, copywriting, data analysis, legal review, and customer support can now each be outsourced to a model at a fraction of the cost and delay of hiring someone or briefing an agency. The Coasean boundary of the firm is shrinking faster than handwriting on a birthday card when you started too big and now have to fit “and all the best for the year ahead” into a space the size of a stamp.

What once required a department can now be handled by a subscription. What once required a company can now be handled by one person with a laptop and a few API keys. The organisational unit of production is shifting toward the individual, not because individuals have become smarter, but because the cost of coordinating with machines has fallen below the cost of coordinating with people.

William Baumol identified in the 1960s that certain sectors—education, healthcare, the performing arts—resist productivity gains because their output depends on human labour that cannot be sped up. A string quartet cannot play faster. Well, yes, if we’re being pedantic, they can technically play a higher tempo, but you still need the same number of musicians.

Baumol’s cost disease meant these sectors became relatively more expensive over time as productivity gains elsewhere pushed wages up. AI is now targeting these sectors—the ones that resisted automation for sixty years: legal drafting, medical triage, tutoring, and content production. The string quartet still needs four musicians, but the administrative apparatus around it—booking, marketing, programme notes, grant applications—can now be handled by a model that charges by the token.

Paul Romer argued in his 1990 growth theory that ideas are non-rival goods. In other words, my use of an idea does not diminish yours. This quality makes ideas the engine of endogenous growth, and Romer won a Nobel for formalising this. But non-rival also means non-excludable in practice, and that is the crux. When execution was the moat, a good idea was protected by how hard it was to build. You could see what a company was doing and still not be able to replicate it, because doing so required a hundred engineers, a regulatory team, and an advertising war chest.

When execution compresses to near zero, an idea becomes copyable as soon as it becomes visible, and defensibility shifts. It moves from the ability to build to the ability to occupy a market, accumulate trust, own distribution, and compound a relationship that a late entrant cannot shortcut. The moat was once technical, but increasingly it is relational.

The niche dividend

Chris Anderson’s 2004 long tail thesis argued that the internet would unlock markets for products too niche for physical shelf space. He was right about distribution. A printed book that would never survive in a Waterstones could still sell steadily through Amazon. But production cost remained a constraint. For anything of quality, you needed a decent author, an editor, and perhaps a designer and a typesetter. The long tail of distribution met the stubborn floor of creation cost, and the tail stayed thinner than the theory promised.

That floor is now finally collapsing. When a solo operator can build, ship, and maintain a software product for a few hundred users at near-zero marginal cost, markets that were never economically viable start to open. A scheduling tool for independent dog groomers. A compliance tracker for small-batch distilleries. A booking system for narrowboat holiday lets. None of these justify a venture funding round. None of them justify a ten-person team. But they might justify one person spending a weekend, and if each niche sustains a livelihood, the aggregate reshapes the economy from below.

The interesting consequence is distributional. The venture model favours large addressable markets because venture economics depend on massive returns from a few bets. When production costs fall to near zero, the minimum viable market falls with them, and the range of problems worth solving expands dramatically. An economy of a thousand niches looks nothing like our current winner-take-all platform economy. It is more artisanal and more fragmented, which, depending on your politics, is either a return to the workshop or a race to subsistence. Probably both.

The last scarcity to fall

With production costs collapsing, the niche dividend means markets of 500 people are now viable. But a viable product still has to find its people, and for most of the internet’s history that has been the remaining bottleneck—the part you still needed money to solve. That constraint is thinning, too.

Galbraith’s dependence effect—manufacturing demand to absorb production—gets a turbocharged sequel. Advertising has become more targeted for decades, and the trend points toward almost perfect transactional reach. You can find your 500 potential customers with a budget measured in thousands of pounds rather than hundreds of thousands, because the ad platforms’ own AI will know who those people are before you do.

Herbert Simon observed in 1971 that a wealth of information creates a poverty of attention. That observation has aged well. But when reach becomes cheap, and attention remains expensive, the question flips from “how do I find my audience?” to “why should my audience pay attention to me?” Distribution, the second-to-last scarcity, is dissolving. What remains is trust, taste and reputation.

Follow the chain all the way down. Production is cheap. Distribution to a niche is cheap. Reach is becoming increasingly transactional. Every historical constraint in the sequence from idea to customer is compressing into a commodity. So what, if anything, is still hard?

Where scarcity remains

Three things remain scarce, and they are the things that no model has yet compressed.

The first is sound judgment, and its less obvious twin is focus. Ideas were never the scarce input; validation was. The shower is full of ideas. Most of them are bad, and the ones that aren’t could be bad for you specifically unless you have the domain knowledge, relationships, or positioning to execute them credibly. Cheap execution gives you cheap testing. You can build and ship a version in a weekend, discover that nobody wants it, and walk away having lost a weekend rather than a year. The scarce resource isn’t the idea, but the capacity to choose the right one and kill the wrong ones quickly.

But selection is only half the discipline. The other half is refusal. When you can build anything easily and cheaply, the temptation is to build everything, and those who give in end up with products bloated with features that seemed like a good idea at the time or met some idiosyncratic customer need. The ability to look at a viable idea and say “not this, not now, not us” is much harder when the build cost is zero, because the cost no longer enforces the constraint for you. Focus used to be imposed by scarcity. Now it has to be chosen, which is a fundamentally different demand on the person making the calls.

Michael Polanyi’s work on tacit knowledge sharpens this further. You often can’t articulate what you know until you try to build it, and the building reveals the knowing. Cheap execution speeds up that feedback loop, but it does not replace the knowledge behind it. The valuable judgment is not the kind you can write down. It is the kind you build by failing at the right speed.

The second is trust. George Akerlof’s market for lemons applies with force when production cost stops signalling quality. If anyone can ship a basic SaaS product in a weekend, many people will, and most of what they ship will be mediocre, unmaintained, and abandoned within six months. The buyer’s problem shifts from “can I find a solution?” to “can I find a solution that will still exist next year?” Provenance, track record, visible commitment to a market — the things that take time to accumulate and cannot be faked by a model — become a moat. The flood of cheap production paradoxically re-financialises quality. Being ok is table stakes. Being trustworthy is the differentiator.

This connects directly to the distribution question above. When reach is transactional, but attention is increasingly scarce, the only signal that breaks through is reputation—earned by showing up consistently in a specific market and being right more often than not. Cheap reach without earned trust is a loudspeaker in an empty field.

The third is organisational, and it comes from the consulting angle rather than the MBA reading list. Software execution is increasingly solved; execution inside organisations is not. Integration, compliance, change management, the politics of a twelve-person leadership team that cannot agree on what the software should do, and a regulatory environment that changes requirements halfway through the build all get in the way. The last mile of implementation remains stubbornly human, because the last mile is not a technical problem; it is a social one. Anyone selling the idea that AI dissolves all execution friction is either lying or has never tried to get a procurement team at a local authority to sign off a new vendor.

The uncomfortable implication is that most traditional companies are not well-run machines temporarily held back by expensive execution. They are inefficient, often bordering on dysfunctional organisations, where misaligned incentives, siloed teams, and institutional inertia absorb most of the energy that is nominally directed at getting things done. Cheap AI tooling does not fix this. It makes it more visible, because when the technical excuses disappear, organisational decrepitude has nowhere left to hide.

What those companies will look like in five years deserves its own article, but the short version is that Coasean logic cuts both ways. If the boundary of the firm shrinks because transaction costs fall, then large companies survive only if they can truly do something a network of smaller operators cannot — things like coordination at scale, regulatory moats, or capital-intensive infrastructure. For the many firms whose advantage was never much more than “we already have the team assembled”, that advantage fades quickly.

What follows

If that all sounds depressing, it need not be. Each remaining scarcity points to something practical.

If judgment is the scarce input, then the skill is not prompting or building, but selecting. People who succeed will treat every project as a probe rather than a product—ship, watch what happens, and build the pattern recognition that helps them spot a viable niche before the data confirms it. This discipline is not creativity. It is the willingness to throw away what you just built because the signal said no.

If trust is the moat, then owned distribution compounds and rented reach does not. An email list, a reputation in a specific community, and a body of published thinking that people return to because it has been right before are assets that survive platform churn. The advantage is not technical. It is relational, built on years of presence in a market and a clear, credible, visible commitment to it.

If the organisational last mile resists automation, then the consultancy that helps a company figure out what it needs before handing the build to a model has a durable role, even (or especially) in a world where the build itself is trivial. Knowing what to build, within the messy constraints of an organisation with competing priorities and legacy systems, is a different kind of judgment from niche-spotting. It is slower, more political, and just as resistant to automation.

The Galbraith turn

Galbraith died in 2006, just before the inversion his framework predicted. He understood that production had ceased to be the constraint and that the economy had reorganised itself around creating and manufacturing demand. He would have recognised at once what is happening now, the next turn of the same wheel. Cognitive and creative production is ceasing to be the constraint, and the economy is beginning to reorganise around what remains scarce: taste, judgment, trust, and the willingness to commit to a specific group of people and their specific problems, rather than building for everyone and therefore for no one.

The hard work has not disappeared. It has migrated, as it always does, to where the machines have not yet followed. The people who notice where it has gone, and get there first, will build the things that last. Everyone else will build a thousand apps in a thousand weekends and wonder why nobody cared.

Tech frontendaidesign

Fewer slides, more dragons

Stripe's Michelle Bu suggests banning slide decks in favor of AI-generated interactive web applications to create more engaging and collaborative presentations.

Summary

What: By using coding agents, teams can build interactive visualizations like planetary systems or 'tech lead villages' to communicate strategy, which reportedly reduces meeting fatigue and improves engagement compared to traditional templates.
Why it matters: The low cost of generating functional UI code shifts presentation design from a static pixel-pushing task to a creative, interactive medium that encourages iterative collaboration.
Takeaway: Next time you need to present, ask your coding agent to generate a simple interactive web-based visual (like a timeline or system diagram) instead of creating a standard slide deck.

Original Article

Fewer slides, more dragons

What happened when I banned myself from making slides

Here’s a familiar sight that could send a typical tech manager into hours of procrastination and avoidant behavior:

It starts with a simple ask for a meeting or a presentation. No matter how pretty the template is, as soon as you decide you need “some slides,” you find yourself slinking down a path of obsessive pixel-pushing.

And it gets worse when inevitably you need a coworker to contribute some content. One understandably tries to cram as much text as possible into their space in 6pt font, while another (maybe a designer) prefers short sentences with bold words. You now get to make these look like they belong in the same presentation.

Five hours later, you have the perfect build, with diagrams and animations to make your slides more compelling, educational, and memorable. As you gaze upon your mediocre masterpiece, you wonder whether those hours were worth it.

You still need to communicate information with clarity, but maybe the medium has to change.

Banning slides

At Stripe, I have been accused of saying that we should ban slides. I may have said these words in anger after the fourth meeting of the week where my slides’ colors were slightly wrong because someone had pasted them in and had “matched styles in this presentation.” Most of the time, this may be an eyesore but doesn’t really matter; in this case, my green “on track” status badge had morphed into a dull yellow in the new theme.

I may not have meant it, but it’s an interesting provocation, especially when AI makes the alternatives much cheaper. Sometimes you have to take away the rotary phones to get people to use new technology.

So, I decided to try banning myself from creating slides for any reason, forcing myself to use AI to create interactive presentations instead.

Without much effort (and in under 30 minutes), you can create a Bauhaus-themed interactive strategy explainer…

Or a planetary system explaining what your team does…

This experiment has been surprisingly successful. Tired and busy Zoom brains might immediately check out when they see a slide deck, but a planetary system! Wow! That catches their attention long enough to get your point across, making meetings much more fun and efficient. And after the meeting, you can send them a link to explore the solar system on their own time. They may accidentally internalize your key points as they’re playing around with it. 🙂

Collaborating

With traditional slide decks, collaboration feels like a burden. Someone might mess up your template, or use the wrong font. At the end of the day, despite your efforts, slides made by different people who own just one section will likely result in a jarring experience (or at best a “mid” experience).

On the other hand, everyone has fun building low-stakes, vibe-coded webpages together. I can ask my agent to fix the layout instead of moving everything around myself. I found that after folks see others doing it, they do it themselves because it saves time while allowing them to be more creative.

Moving towards the extreme end of collaboration, I created a village of cross-org tech leads as an icebreaker exercise for an onsite. I was nervous about how it’d go given how many humans and their agents were contributing, but folks seemed to enjoy vibe-adding themselves to our tech lead village, and an old, non-AI innovation called git kept everyone’s contributions manageable.

And they kept adding to it as the day progressed.

It started with a tech lead from Risk adding a dungeon and a dragon to represent the dragons the team slays for us. Inspired by that customization, others started to add their own. By the end of the day, there was a Live MaaS sign and the Pacifica Taco Bell representing the MaaS (Money as a Service) team. There was also a DEEP lake representing DEEP (Developer & End-user Experience Platform), filled with DEEP sea creatures.

Someone eventually added a way for tech leads to explore other teams, so we could see the inside of the Risk dungeon, the Pacifica Taco Bell, and the DEEP lake.

This was the first time I’d seen people engage with the creation of an icebreaker activity or presentation beyond the bounds of the activity itself. Like, it’s literally fun to code with your coworkers and riff off of each other’s ideas. It’s all low-stakes code, and our agents help us write it and make small tweaks. If a different metaphor or idea comes to mind, you can ~easily and ~cheaply start from scratch.

The village icebreaker got me rethinking other group activities I’d traditionally done in slides or Figma. Here’s a fun storybook holiday book exchange that I previously would have run in Figma, but is now interactive and ~infinitely customizable. If you’re at Stripe, you can just point your agent at the linked AGENTS.md and ask it to build one for your team on our internal infra.

How to actually do it

This is basically just “how to vibe code a basic webpage with your friends,” but it’s worth writing down, as I find that folks sometimes hold themselves back from applying AI to well-understood use cases like creating compelling presentations.

I am impatient, so I prefer simplicity above all else. In fact, I find that simple prompts work best for divergent work like brainstorming, naming, or picking a visual direction. To that end, there’s nothing super fancy or really even a “workflow” to tell you about here. I asked my agent to put these steps together:

  1. Have an idea you want to present. This is the most important part. Maybe it’s a doc, some quick bullets, or a stream of consciousness you sloppily typed on your phone on the ferry ride into the office.
  2. Ask your coding agent for a few ways to explain it. Maybe it’s a lifecycle, a planetary system, or something you haven’t thought of. Have it make quick mocks so you can see what works. (You can repeat this step until you’re happy with the concept.)
  3. Pick a concept and play with the visual style. I’m a fan of pixel art and Bauhaus, but you can ask your agent to cook up a few directions. Repeat until you find something you like.
  4. Build it and iterate. Ask your agent to change the content, tweak the visuals, or add interactions and animations. You can get much more creative than you could in slides without moving every little thing yourself.
  5. Make it easy for others to contribute. Ask your agent to create an AGENTS.md explaining how the project works and how to contribute. Then your coworkers and their agents can take it from there.

You can keep going forever, of course. I stop when I have something that gets the idea across. For me, this consistently takes less time than making slides, and my agent can crank away on iterations in the background.

If you’re just presenting, you can run it locally; you only need to deploy it if you want others to explore on their own. And if you need presenter mode with your script, just ask your agent to build it.

My pithy learning from this experiment: AI can help us create conditions for creativity to emerge, even when doing pre-singularity activities like presentation creation and icebreakers. When you make something people want to engage with, it unlocks more ideas, opens more doors, and hatches more dragons than a slide deck ever could.

Tech aiagentsfrontend

My Chrome extensions are just prompts

Paul Kinlan built a Chrome extension framework called 'Prompt in a Box' that creates functional browser tools entirely from natural language prompts.

Summary

What: The framework uses a 'code_mode' approach to execute small async scripts in a sandboxed iframe, enabling complex browser automation like tab organization or history analysis. It manages state via OPFS and Chrome storage, supports an 'undo' journal for non-deterministic agent actions, and requires developer mode for installation since it relies on dynamic code execution.
Why it matters: This signals a future where software is hyper-customized by users via natural language, effectively creating a 'programming by prompt' paradigm that could protect specific tools from being replaced by generic, all-encompassing LLM assistants.

Deep Dive

  • The project uses a 'code_mode' (inspired by Pi.dev) to allow the agent to write and execute small scripts for batch processing instead of performing high-latency sequential API calls.
  • Security is managed by sanitizing browser data and using an isolated, sandboxed iframe for dynamic code execution to mitigate risks from untrusted web content.
  • Architecture relies on three core files: prompt.md (the logic), manifest.json (permissions/contract), and config.json (settings).
  • The framework exposes ~50 Chrome APIs as tools, but access is strictly gated by the manifest permissions.
  • An undo journal is implemented for every tool that modifies state to account for the non-deterministic nature of LLM reasoning.
  • UI can be defined via JSON schema to keep the agent's focus on logic rather than layout.
  • Persistent state and audit logs are maintained using the Origin Private File System (OPFS).

Decoder

  • OPFS (Origin Private File System): A high-performance, private file system API that allows web applications to store and retrieve data in an isolated environment.
  • Code_mode: An architecture where an LLM writes and executes code scripts rather than performing step-by-step chat interactions, significantly reducing token consumption and latency.
  • Service Worker: A script that your browser runs in the background, separate from a web page, enabling features like event-driven processing without requiring the user to keep a specific tab open.

Original Article

my chrome extensions are just prompts

Earlier this year I wrote about how more and more of my software is just prompts and how I built an agent harness that was used to help me ship a prompt as a Chrome Extension, and the more I’ve got into it the more I’ve been able to customize Chrome to my intent with little mini-agents that run with the aim of doing one thing well. Why? Because I think we as an industry need to be pushing more on the concepts of the Web Browser and how to find ways for it to be a sustainable view on the web in the future.

So, without much further ado, announcing: Prompt in a Box…. err, I need better names, and not to do the same thing that I’ve already announced in a post 6 months ago… This time it’s different though, I swear it is. I updated the project a fair bit to make it very easy to experiment with the concept of building programs entirely from a prompt.

You can describe how you want the extension to work in relatively straightforward terms in Markdown format. At the simplest level you can provide a very simple prompt like De-duplicate my tabs and when the extension is invoked it will de-duplicate your tabs to the best it can work out. Naturally, this is very broad and you most likely want even more control. Should it run every 10 minutes, or at the end of your day? What are the cases that you don’t want it to work? Should it just look at the URL or should it consider the content too? What should it do when you are using the tab? Well, for any of those questions you can just write it down.

The “prompt in a box” project was pretty capable when I made it earlier this year, but it was just a bunch of scripts to take markdown files and throw them into a crx bundle. As I was experimenting with this project and sharing it with some teams to enable rapid prototyping of features there were a couple of additional things that we wanted from the platform:

  • A UI that makes it easy to edit all the assets needed for an Extension - the Studio now lets you create all the icons, select or infer permissions and also have an agent help you define the parameters and logic further than your original prompt.
  • A deterministic way to build UI for the popup - you can now do that with a JSON schema that can be inferred from the prompt. If you don’t, the agent will decide how to render the UI (if UI is even needed)
  • Because the results are non-deterministic, people needed a way to Undo the action if the extension got it wrong
  • There needed to be a full trace and accountability so that we can review how the harness works especially when it went wrong. This is critical so that you can refine your prompt
  • Agent Harnesses are normally a step-by-step conversation with an LLM service and this can be quite slow. If you have 50 tabs and you have to analyse the content of each, do you do 50 LLM steps, or think of another way? The other way is code_mode inspired by Pi.dev where the agent will dynamically write the code for part of the extension steps and then run it in batch.

You will not be able to submit any of these extensions to the Chrome Web Store, sorry. They rely on dynamic code execution either directly through code_mode or indirectly through the agent loop.

I noted in shipping a prompt that I think Chrome Extensions are already a good sandbox and model for an agent. It’s a zip file with a manifest. It has a permission model, a sandbox, an event system that wakes it up and a way to distribute it, and we really push it, an Agent is an extension with a prompt.md.

The Studio allows you to download the extension and if you look at it, it is made out of the same three files (plus the runtime of course):

  • prompt.md - what the extension should do. This is the program.
  • manifest.json - what the extension is allowed to reach. Permissions are the contract.
  • config.json - the knobs that you set that define which models are allowed, the schedule and how often it runs, and any other user-facing settings and which bits and bobs of UI to show.

Nothing in the runtime knows anything about tabs or bookmarks or any other APIs directionly, instead you swap the prompt and the same code becomes a different tool.

The service worker is the heart of it (I mean, it is a Chrome Extension after all). It runs agent-do as the loop and exposes nearly every single one of Chrome’s APIs as tools (there’s about 50 of them now, e.g tab_list, tab_group, bookmark_search, history_search, notification_show etc). Each tool of these tools are gated by a Chrome permission (optional by default). So if the manifest doesn’t grant bookmarks, the bookmark tools are simply not in the list that the model sees and it will not be able to ask for it.

I also maintain state in two places: OPFS (really, this API is incredible, I’ve used it in so many projects recently) gives the agent a file system for artifacts that they create (you could have an extension that creates reports from your history etc), the audit log and the event queue, and chrome.storage.local holds the settings and the undo journal so that you can back changes the Agent made. Your API key stays in the browser and the only network calls go to the model provider that you picked (Gemini, Claude or GPT, unfrotunatly the Chrome Prompt API is not powerful enough yet).

I think it gets pretty interesting when you thing about how the Agent runs.

  1. Wake. Something wakes the service worker: a chrome.alarms ping, a browser event such as onTabUpdated, the user clicking on “Run now”, or the extension being installed or updated. I made it so that the system thinks of Events in two ways a) things the user is waiting on (a context menu click, a keyboard shortcut, an omnibox entry) trigger a run immediately. b) Ambient things (a tab opened, a bookmark added, a download finished) which get appended to a queue in OPFS and are handed to the prompt on the next run and don’t need to be processed immediately
  2. Load. It loads prompt.md and builds the tool set from the permissions that have actually been granted.
  3. Compose. It builds the first message for the model with the local time, the user’s settings, a snapshot of the open tabs and groups, and the events that have queued up since last time.
  4. Loop. agent-do (I might exchange this for the Pi API soon) runs the loop: the model asks for tools, the tools run, the results go back.
  5. Record. Every tool call, the tokens and the cost are written to the audit log, and anything that changed the browser gets an entry in the undo journal.
  6. Sleep. The loop finishes and Chrome kills the service worker because I don’t want this just staying residient in memory all the time.

code_mode: let the model write the loop

The simple way to organise 50 tabs is for the model to call tab_read 50 times, with each of these being a round trip to the LLM. As with all chatty interfaces it’s slow and now with LLMs it’s hella expensive. I followed the ideas from Pi and implemented a code_mode where the model writes a small async script and the extension runs it. Something like this:

const tabs = await tools.tab_list();
const pages = await Promise.all(
  tabs
    .filter((tab) => tab.canScript)
    .map((tab) => tools.tab_read({ tabId: tab.id, maxLength: 500 }))
);
return pages.map((p) => ({ id: p.tabId, title: p.title, excerpt: p.excerpt }));

Now 50 tabs can be read in parallel, and only the distilled result goes back into the conversation. It speeds things up a lot (from minutes per run to seconds in some cases).

I was quite happy with where I got the code to run, because by default an extension’s service worker can’t eval anything because of the tight CSP in the extensions platofrm. So the code-mode takes a bit of a journey through the Service Worker which then hands the code off to the offscreen document, which hosts a sandboxed iframe, and that iframe is the only place in the whole extension where dynamic code is allowed to run.

The sandbox has an opaque origin and no chrome.* APIs and no network (connect-src 'none'). The only thing the script can do is call tools.<name>(), which is a postMessage back to the service worker (postMessage is my fave), where the real tool runs with the same permission checks as any other call.

Compile things that should be repeatable

I was in two minds about this. On one hand I wanted the extension to be completely agent derived which means that I had to make a decision on if after the same event happens (say onTabUpdated), should the logic that is run via the agent be exactly the same every time? I think the default answer is: Yes, obviously because users would hate it if it was different. HOWEVER, I really like the idea that previous steps could influence future iterations and that we build emergent systems out of the changing state that our extension has built.

In the end, I just made it so that the system can save a script it wrote with saveAs, and it can bind that script to a Chrome event such as tabs.onUpdated. The next time that event fires, the saved script runs first.

Deterministic UI

I’m not sure if I’m too happy about this. But a lot of feedback that I recieved from teams is that they need to define a way to make UI consistently and easiliy. I followed some of the techniques that I found in A2UI and I added support for adding a fenced ui block to prompt.md, the popup and side panel are rendered from it. It does mean there is no HTML and no need for framework. But it also is one of the areas where I think regular people would clearly struggle and I want a better way to define UI.

This is pretty much the whole UI for the Sorting Hat tab organiser example (trimmed a little):

```ui
{
  "title": "Tab Organizer",
  "components": [
    { "type": "text", "text": "Intelligently organizes your open tabs into contextual tab groups." },
    {
      "type": "button",
      "text": "🪄 Sort Tabs Now",
      "action": "trigger-run",
      "payload": { "command": "sort_tabs_now" }
    },
    { "type": "divider" },
    {
      "type": "action-history",
      "text": "Recent Sorting Actions",
      "limit": 15,
      "showUndoAll": true,
      "undoAllLabel": "Undo Last Sort"
    }
  ]
}
```

OMG. What did you do!?!?… Undo

Everyone I spoke to wanted to be able to undo the actions the Agent took. Firstly, we don’t always have confidence the agent will get things right, so you need to be 100% confident that you can undo. Unfortunately, you can’t ask an LLM to “undo that thing you just did” and trust it to remember what it did.

I made it so that every tool that changes something also records how to reverse it before it makes the change. Grouping tabs will store which group each tab was in before. Closing a tab stores its URL, window, position and whether it was pinned. Setting a storage key stores the previous value.

I don’t trust you. Trace everything

Every run gets records a full record of everything that happened: what triggered it, the model, every tool call with its arguments, result and timing, the token counts and an estimated cost. It all goes into OPFS that you can browse, filter and export all of it from the options page. There is also a live console that streams the run as it happens, including the model’s reasoning.

Treating the web as untrusted

Page titles, URLs and page text all end up in the model’s context, and all of them are written by someone else. Everything that comes from the browser is sanitised and wrapped in a clearly marked “this is data, not instructions” fence before the model sees it, and a page can’t close that fence itself to break out. It’s a mitigation and not a solution.

Wrapping up

I really liked this project not only because we’ve used it to test some early concepts and it showed me how valuable the rapid iteration is, but also because it furthered my thinking on how we can compose agents from small prompts into useful experiences and how systems built around extensions can enable more customizable products that can be as simple or as complex as you need.

As people build more agentic software we are going to have to think about how our existing surfaces can enable tooling to be built around them. I constantly think about how spreadsheets made millions of people programmers, without them actually knowing they were. We should all be considering how our products can enable not only orchestration by agents (e.g., MCP) but how the functionality of the product can be customized by our users from within the product. I also think it gives software a chance to survive against the onslaught of LLM harnesses that are racing towards being the one true and only application that you will ever need.

Make your software so indispensable to your users because they customized it to their needs and moving to another platform or tool makes no sense.

This project and the concept of extensible and customizable software is not without risk. While these extensions would not be allowed in the Chrome Web Store and can only be loaded in “developer-mode”, if this is a future to how software is created then how do we enable more people to safely run prompts or non-deterministic software? Do we need better virtualisation? Do we need to provide better segregation between the user-defined extension and the site they are operating on? It seems to me that it’s quite possible to imagine a world where a specially crafted web page could influence the execution of the extension in future runs to extract sensitive information or manipulate a page to hide some other actions the tool has taken.

Risky but fun. Seems to be the motto of a lot of LLM-powered software these days.

That’s it for me. I really just wanted to give you a glimpse of you being able to hyper-customize Chrome with just a few prompts. Have fun.

Data securityprivacy

De-identifying text at scale: How Airbnb protects personal data in AI training

Airbnb unified its privacy protection by turning data policies into reusable, testable code controls within its ML pipeline.

Summary

What: Airbnb adopted Microsoft's open-source Presidio to automate PII de-identification as a standard pipeline step, ensuring training data is sanitized before entering shared model registries.
Why it matters: This signals a shift toward treating privacy as a testable software engineering requirement rather than a manual governance checkbox, essential for scaling safe AI development.

Deep Dive

  • Implemented Microsoft Presidio as an in-process pipeline component.
  • Added domain-specific custom recognizers for Airbnb's internal data formats.
  • Added multilingual evaluation to support global datasets.
  • Enforced de-identification via model registry metadata tagging.
  • Shifted from manual data masking to a reusable, automated control framework.

Decoder

  • PII: Personally Identifiable Information; any data that could potentially identify a specific individual.
  • De-identification: The process of removing or obfuscating identifying information from datasets to protect user privacy.

Original Article

Training teams need realistic text data without letting PII leak into shared ML workflows. Airbnb packaged open-source Presidio, originally developed by Microsoft, as an in-process pipeline step, added domain-specific recognizers and multilingual evaluation, and then tagged de-identified datasets through its model registry. The useful pattern is turning privacy policy into testable, reusable data controls rather than asking every team to improvise.

Data databaseinfrastructureiceberg

MySQL tables in four open source Iceberg catalogs, read by Trino and DuckDB

Exporting MySQL changes to open-source Iceberg catalogs reveals significant interoperability gaps in credential vending and delete support.

Summary

What: DBTrail tested four open-source Iceberg catalogs (Project Nessie, LakeKeeper, Apache Polaris, Apache Gravitino) using MySQL binlog exports, finding that credential management and equality delete support vary significantly across implementations.
Why it matters: The industry is pushing to treat transactional databases as Iceberg producers, but standardized credential handling remains a major hurdle for seamless integration.

Deep Dive

  • Exported MySQL 8.4 data to Iceberg REST catalogs via binlog following.
  • Validated data integrity using Trino 484 and DuckDB 2.0.0.
  • Project Nessie 0.110.0 required no configuration changes.
  • LakeKeeper 0.15.1 failed until remote S3 signing was disabled.
  • Apache Polaris 1.9.0 and Gravitino 1.3.0 required upcoming patch releases to handle credential delegation.
  • Equality deletes in Iceberg remain a compatibility challenge for some client libraries like PyIceberg.

Decoder

  • Binlog: MySQL binary log; a set of files that contain information about data modifications made to the database.
  • Iceberg Catalog: A management layer that tracks the state and metadata of tables in an Apache Iceberg data lake.
  • Credential Vending: A security mechanism where a catalog server grants temporary, scoped storage access (like AWS STS tokens) to a client to prevent sharing permanent credentials.

Original Article

A team that wants to know how much revenue came from each customer segment needs two things that live in different places: the orders, in MySQL, and the segments, in whatever the sales team uses. Someone usually exports both into one database by hand, or builds a pipeline and then looks after it.

If your company already runs an Iceberg catalog, DBTrail can put the MySQL tables there. It keeps a copy of your MySQL tables as Iceberg tables and registers them in that catalog under their own names, shop.orders, shop.customers. Any engine that reads the catalog can then query them by name and join them with the other tables registered there. When MySQL changes, the next export adds only what changed.

We tried this with four open source Iceberg REST catalogs and two query engines, Trino and DuckDB, and compared every answer with the same query on MySQL.

What we tested

One MySQL 8.4 server with a small shop: 200 customers and about 5,000 to 6,000 orders, with a script writing about nine statements a second (half inserts, the rest updates and deletes). DBTrail 0.133.0 followed the binlog, then exported to each catalog twice: a first load, then, after 40 more seconds of writes, an incremental export carrying the inserts, updates and deletes.

Then each engine read the tables by name through the catalog, with the writes stopped, and we compared row count, the exact sum of the amount column, the highest id and the number of paid orders with the same query on MySQL.

Catalog DBTrail 0.133.0 Trino 484 DuckDB 2.0.0 CRM join
Project Nessie 0.110.0 works as is Matches Matches Matches
LakeKeeper 0.15.1 works with remote signing turned off Matches Matches Matches
Apache Polaris 1.9.0 refused with its storage set to “no STS”; works with two changes due in the next release Matches Matches Matches
Apache Gravitino 1.3.0 refused; works with a change due in the next release Matches Matches Matches

“Matches” means every one of the five numbers matched, after the incremental export.

The export

The export command with Nessie, which needed no extra options:

bintrail export iceberg 
  --index-dsn "root:...@tcp(127.0.0.1:3307)/bintrail_index" 
  --baseline-dir /opt/rig/baselines 
  --catalog rest 
  --catalog-uri http://localhost:19120/iceberg 
  --catalog-warehouse dbtrail 
  --warehouse s3://<bucket>/iceberg/nessie 
  --format json

The second run, after 40 seconds of writes, took 0.8 seconds:

"table": "customers", "verdict": "unchanged", "detail": "no events since the cursor"
"table": "orders",    "verdict": "exported",  "detail": "374 events folded into 333 upserts and 31 deletes"

Run the same line from cron, or add --every 15m and leave it running. Each run reads only the changes since the one before. The position each table has reached is stored in the table’s own properties, in the same commit as the data, so the export keeps no progress of its own outside the catalog.

Reading the tables by name

Trino, with the stock Iceberg connector pointed at the catalog:

connector.name=iceberg
iceberg.catalog.type=rest
iceberg.rest-catalog.uri=http://localhost:19120/iceberg
iceberg.rest-catalog.warehouse=dbtrail
fs.native-s3.enabled=true
s3.region=us-east-1
SELECT count(*), sum(amount), max(id), count_if(status = 'paid'),
       (SELECT count(*) FROM shop.customers)
FROM shop.orders;
"5568","1395471.20","5695","1290","200"

DuckDB 2.0, attaching the same catalog:

INSTALL iceberg; LOAD iceberg; INSTALL httpfs; LOAD httpfs; INSTALL aws; LOAD aws;
CREATE SECRET s3c (TYPE s3, PROVIDER credential_chain, REGION 'us-east-1');
ATTACH 'dbtrail' AS c (TYPE iceberg, URI 'http://localhost:19120/iceberg',
                       AUTHORIZATION_TYPE 'none', ACCESS_DELEGATION_MODE 'none');
SELECT count(*), sum(amount), max(id), count(*) FILTER (WHERE status = 'paid')
FROM c.shop.orders;
5568 | 1395471.20 | 5695 | 1290

MySQL, at the same moment:

{"orders_count": 5568, "orders_sum_amount": "1395471.20", "orders_max_id": 5695, "orders_paid": 1290}

Two DuckDB details. The read failed with HTTP 403 ... No credentials are provided until we set ACCESS_DELEGATION_MODE 'none', because the catalog hands out no storage credentials, even with an S3 secret in place. And every query here reads the key column (max(id) above does): the export’s documentation explains that older DuckDB releases need it to apply the deletes of an incremental export. We did not check whether 2.0 still does.

The join

To stand in for data from another system, we took a CSV with one row per customer (customer_id, segment, account_manager) and registered it in the same catalog as crm.customer_segments, with PyIceberg:

cat = load_catalog("rig", type="rest", uri="http://localhost:19120/iceberg", warehouse="dbtrail")
cat.create_namespace("crm")
t = cat.create_table("crm.customer_segments", schema=tbl.schema)
t.append(tbl)   # 200 rows from the CSV

Revenue per segment, with the orders from MySQL and the segments from the CSV:

SELECT s.segment, count(*) AS paid_orders, sum(o.amount) AS revenue
FROM shop.orders o
JOIN crm.customer_segments s ON s.customer_id = o.customer_id
WHERE o.status = 'paid'
GROUP BY s.segment
ORDER BY revenue DESC;

Trino:

"self-serve","343","87947.70"
"mid-market","343","84817.69"
"smb","314","77131.70"
"enterprise","290","73062.86"

DuckDB returned the same four rows, and MySQL, joining its own tables with the same segment rule, returned the same four rows. We repeated this on all four catalogs; each time the three answers were identical.

Catalog by catalog

Project Nessie 0.110.0 worked with the release as is. Nessie picks its own table location under the warehouse (it adds a suffix such as orders_01f46bad-...), which changes nothing for the readers.

LakeKeeper 0.15.1. A warehouse on S3 without STS defaults to remote signing: the catalog tells the client to send every S3 request to the catalog to be signed. The Iceberg library DBTrail is built on cannot do that, and the first run stopped with:

failed to load metadata file at s3://.../orders/metadata/00000-....gz.metadata.json:
remote S3 request signing is not supported

With remote signing turned off for the warehouse ("remote-signing-enabled": false in its storage profile), the export used the machine’s own AWS credentials and everything matched. The two empty tables the failed run had created were loaded by the next run with no manual step.

Apache Polaris 1.9.0 needed two changes in DBTrail. First, signing in with a client credential failed:

invalid_scope: The scope is invalid

DBTrail asks for the OAuth scope catalog, and Polaris wants PRINCIPAL_ROLE:ALL. With 0.133.0 you can fetch a token with that scope yourself and pass it in BINTRAIL_ICEBERG_CATALOG_TOKEN, and the sign-in works. But the token expires after an hour and nothing renews it, which is a problem for an export that runs every few minutes. A change due in the next release adds --catalog-scope (dbtrail/dbtrail#2928), and with it the credential signs in and is renewed on its own:

export BINTRAIL_ICEBERG_CATALOG_CREDENTIAL='<client_id>:<client_secret>'
bintrail export iceberg ... --catalog rest 
  --catalog-uri http://localhost:8182/api/catalog --catalog-warehouse dbtrail 
  --catalog-scope PRINCIPAL_ROLE:ALL

Second, DBTrail asks the catalog for temporary storage credentials on every request. In production Polaris gets them by assuming an IAM role you give it. We did not set up an IAM role for this test, so we tried two other setups. With a Polaris option meant for development only (SKIP_CREDENTIAL_SUBSCOPING_INDIRECTION, which hands the server’s own credentials to every client, and Polaris warns about it at start), 0.133.0 with the hand-made token exported and every check matched. That is not how you would run Polaris, so we do not count it. With the storage set to “no STS available”, the setup that is closer to production without a role, Polaris refused the table:

Credential vending was requested for table shop.orders, but no credentials are available

Apache Gravitino 1.3.0, its standalone Iceberg REST server with no credential provider configured, refused for the same reason:

No credential provider found for path s3://.../gravitino/shop/orders with scheme s3

We sent the same create request by hand: with the “please vend credentials” header Gravitino answered 400, and without it 200. A second change, also due in the next release, adds --catalog-access-delegation none (dbtrail/dbtrail#2932), which stops asking, so the files are written with the machine’s own credentials. With it, both Gravitino and Polaris with “no STS available” (signing in with the credential and --catalog-scope) passed every check above. A Polaris that assumes a real IAM role and vends credentials should work with 0.133.0 plus a token, but we did not test it. A Gravitino setting to watch: the container’s settings are GRAVITINO_ICEBERG_REST_* variables, and with the wrong names it quietly kept a default warehouse in /tmp inside the container.

Unity Catalog OSS we only tried briefly. Its Iceberg endpoint would not create a namespace (404), and table creation answered S3 bucket configuration not found.: for an S3 table it wants the bucket set up in its server configuration with an access key or an IAM role to hand out, and we had neither. We left it there, so it is not in the table above.

What did not work, and what we did not test

  • PyIceberg cannot read the tables after an incremental export. It stops with PyIceberg does not yet support equality deletes. DBTrail records an update or a delete as an Iceberg equality delete, and PyIceberg does not read those yet. It registered the CRM table without trouble. Trino and DuckDB read everything.
  • PyIceberg could not talk to our Gravitino (NotAuthorizedException), so on Gravitino we registered the CRM table with Trino instead (CREATE TABLE crm.customer_segments AS ...). We did not dig into it.
  • Remote signing (LakeKeeper’s default) does not work with DBTrail; turn it off for the warehouse.
  • Not tested: Polaris or LakeKeeper with real STS credential vending (it needs an IAM role, which we did not set up), Spark, authentication on LakeKeeper, Nessie and Gravitino (they ran open, on the same machine), catalogs on another host over https, and long runs on a timetable through these catalogs.
  • Every catalog here ran with an in-memory or single-container backend. A production setup would use a persistent store.

Try it

The export is in the current DBTrail release, with --catalog rest for any Iceberg REST catalog and --catalog glue for AWS Glue. The full reference, including the flags for authentication, is in the Iceberg export documentation. The two options described above, --catalog-scope and --catalog-access-delegation, are merged and arrive in the next release.

Data aiagentsdata-engineering

Agentic data engineering is here! Project Osmos: What, Why, and How?

Microsoft Fabric's Project Osmos attempts autonomous pipeline engineering, but highlights the persistent need for human-in-the-loop validation.

Summary

What: Project Osmos is an autonomous AI agent for Microsoft Fabric that plans and builds Spark pipelines from specifications, though it remains prone to subtle logic errors, such as timezone handling during daylight saving transitions.
Why it matters: Autonomous agents effectively handle boilerplate, but complex data logic—like domain-specific timezone shifts—still requires expert human oversight to prevent silent data corruption.

Deep Dive

  • Osmos integrates via Claude Code to orchestrate Fabric Spark compute.
  • It supports planning, execution, and validation stages based on user-defined specs.
  • The agent uses manual promotion gates to prevent unaudited code from reaching production.
  • Independent QA pipelines are necessary because the agent may fail to detect logical errors it introduced itself.
  • Latency in agent communication means steering a running task requires patience and strategic step-breaking.

Decoder

  • GTFS: General Transit Feed Specification; a common data format for public transportation schedules and geographic information.
  • Idempotent: A property of operations that can be applied multiple times without changing the result beyond the initial application.

Original Article

Full article content is not available for inline reading.

Read the original article →

Data infrastructure

Rebuilding Data Lineage at LinkedIn: From Storage to Compute

LinkedIn overhauled its lineage platform to track dependencies at the compute level, processing 10 million edges across 6 million datasets.

Summary

What: LinkedIn replaced storage-layer lineage tracking with a compute-based approach using native integrations for Spark, Trino, and Flink to capture exact, query-plan-level data dependencies.
Why it matters: Storage-level observation lacks the semantic precision needed for impact analysis and incident recovery; capturing lineage from query plans enables more reliable automated data operations.

Deep Dive

  • Instrumentation: Unified SDK for Spark, Trino, Flink, and Airflow emits structured lineage events.
  • Storage: Append-only Kafka log for events; MySQL-based graph for traversal.
  • Retrieval: gRPC-based engine handles bread-first traversal with edge-type filters.
  • Semantics: Edges are classified by type (data flow vs. metadata), granularity, and confidence.
  • RDD Handling: Lineage captured at the task-level for non-SQL Spark workloads.
  • Metadata: 'VIEW' and 'REFERENCE' edges capture logical relationships, accounting for 20% of the graph.

Decoder

  • Blast-radius analysis: Assessing the potential impact or 'damage' of a change or failure across downstream dependencies.
  • RDD: Resilient Distributed Dataset; the primary data abstraction in Spark representing immutable partitioned collections.

Original Article

Rebuilding Data Lineage at LinkedIn: From Storage to Compute

Data is foundational to how modern digital products are built and operated. Reliable data helps teams make better decisions, respond to issues faster, and deliver experiences that are relevant, dependable, and secure for members and customers.

At LinkedIn, this challenge exists at significant scale: tens of thousands of data-processing workflows process data from millions of datasets, generating tens of millions of lineage events each day. Data flows from online databases through ingestion pipelines and batch and streaming processing engines into serving systems that support experiences across LinkedIn.

In this blog, we share how LinkedIn’s lineage requirements evolved, why that evolution led us to rethink where and how lineage is captured, and how the rebuilt platform now supports compliance, observability, reliability, and infrastructure efficiency at scale.

How Our Lineage Requirements Evolved

LinkedIn’s original lineage platform was designed for broad visibility across the data ecosystem. Over the past five years, as our data ecosystem expanded in scale and complexity, teams began relying on lineage for a broader set of decisions: investigating incidents, assessing the impact of changes, supporting compliance workflows, and identifying infrastructure that could be safely retired.

This shift raised the bar for what the platform needed to provide. Broad visibility remained valuable, but these new workflows also required precise dataset relationships, end-to-end reachability, timely results, and explicit confidence in each lineage signal. The platform now needed to support day-to-day operational decisions across four areas:

  • Compliance. Governance workflows benefit from a clear understanding of how data moves through complex systems. Reliable lineage provides factual context that facilitate those processes; it does not by itself determine compliance outcomes.
  • Observability. At this scale, identifying stale upstream data, data-quality regressions, and freshness drift requires reliable lineage.
  • Data infrastructure reliability. Trustworthy lineage enables engineers to understand how failures propagate across complex data pipelines.
  • Resource efficiency. Understanding dependencies helps teams identify unused datasets, redundant pipelines, and storage that can be safely retired.

Across these use cases, engineers repeatedly return to a small set of questions:

  • “Where did this data come from?”
  • “What breaks downstream if I change this column?”
  • “What caused the issue in my dataset?”

At LinkedIn’s scale, answering these questions accurately and quickly required capabilities beyond the original design. This evolution in requirements motivated us to rethink the platform from the ground up.

What We Learned From the Previous Design

Our previous lineage platform treated every access path equally, providing broad visibility across LinkedIn’s expanding data ecosystem. As operational use cases grew, we identified opportunities to improve its precision, granularity, relationship semantics, and transparency about signal confidence.

Three design choices highlighted where the platform could evolve:

1. Capture lineage where computation happens. Storage systems can observe reads and writes, but they cannot determine how a compute engine uses them. As a result, storage-level signals are less precise in identifying the producer-consumer relationship and in distinguishing meaningful data movement from temporary files, staging outputs, checkpoints, and shuffle data. They also cannot see query semantics such as projections, filters, or column pruning, which are required for column-level lineage.

2. Preserve exact dataset-to-dataset relationships. Workflow-level aggregation captures the combined inputs and outputs of a workflow, but not the exact mapping created by each computation. Preserving that mapping enables more precise root-cause and impact analysis.

3. Model data-flow and metadata relationships explicitly. A logical dataset may be represented as a Hive table, an HDFS path, or a governed view. Modeling relationships such as VIEW and REFERENCE as first-class edge types preserves their meaning while connecting these representations in a unified graph.

Together, these lessons shaped three requirements for the rebuilt platform: capture lineage from compute execution, preserve precise dataset-to-dataset relationships, and attach explicit type and confidence semantics to every edge. These capabilities support operational workflows such as blast-radius analysis, incident response, and compliance evaluation.

How the Rebuilt Platform Works

The rebuilt platform captures and serves lineage across more than 15 compute, orchestration, and data-movement systems, including Spark, Trino, Flink, Beam, Airflow, Flyte, change-data-capture, and ETL systems. Supported engines emit high-confidence lineage directly, while other sources are integrated as confidence-rated fallbacks.

The platform consists of three major stages: instrumentation, ingestion and storage, and retrieval.

Instrumentation. Every lineage signal uses the same emission format. Native integrations, including Spark, Trino, Flink, Beam, streaming ingestion jobs, change-data-capture streams, and push jobs, emit lineage directly through a lightweight SDK. Where native instrumentation is unavailable, conversion jobs translate legacy signals, such as relationships between Hive tables and their underlying HDFS paths, into the same format. All events then land in a single Kafka topic.

Ingestion and storage. Incoming lineage events are processed by Flink and written to an append-only log that supports auditing and replay. The processor also maintains a merged graph optimized for online traversal. For offline analysis, ETL jobs materialize the same lineage data in warehouse tables.

Retrieval. Online, a gRPC graph engine serves upstream and downstream traversal queries bounded by depth, breadth, edge type, and optional stop conditions. This supports latency-sensitive workflows such as incident response.

The same graph is exposed through three logical views: dataset-to-dataset for tracing data flow, dataset-to-job for execution debugging, and workflow-to-workflow for reasoning about workflow dependencies. One graph, three views.

Offline, the same lineage materializes as warehouse tables for compliance, cost analysis, and pipeline health reporting. The same APIs are also integrated with internal AI-powered engineering tools, allowing engineers to explore lineage using natural language.

Key Design Decisions Behind the Rebuild

Five design decisions shaped the rebuilt lineage platform. Capturing lineage from executed query plans is the foundation; the remaining decisions determine how lineage is transported, stored, queried, and presented.

1. Capture lineage from executed query plans. Lineage can be observed from runtime execution, declared in workflow configuration, or inferred from storage-layer audit logs. We prioritize runtime observation because it reflects the computation that was actually executed.

Engines such as Spark SQL, Trino, and Flink SQL build query plans that describe their inputs, outputs, and column-level relationships. We instrument supported engines to emit structured lineage directly from those plans. Declared and inferred sources remain available as fallbacks and are assigned confidence levels based on how the lineage was captured.

2. Separate lineage submission from presentation. Producers emit high-volume events containing the complete context of an individual job execution. Consumers, however, need to traverse relationships efficiently across many jobs and datasets.

Because these access patterns have different requirements, we maintain an append-only submission log as the source of truth and build query-optimized representations from it. These representations support both online traversal and offline analysis, and they can be rebuilt without requiring producers to re-emit historical events.

3. Use an interoperable, strongly typed emission schema. We aligned our event format with OpenLineage and extended it to support capabilities needed across LinkedIn’s production environment, including RDD-based jobs, Flink column-level lineage, Flyte workflows, and Iceberg-based datasets. Events are transported through strongly typed gRPC APIs, providing consistent schema enforcement across producers and consumers.

4. Build a traversal engine for lineage-specific queries. Lineage traversal differs from generic graph traversal because every query combines graph navigation with lineage-specific semantics: confidence, edge type, granularity, stopping rules, and nodes with large numbers of dependencies. These rules must work together within the same traversal.

We store the graph as an indexed edge table in MySQL and traverse it using a breadth-first-search engine with pluggable rules for stopping, node selection, database batching, and result pruning. This approach provides predictable operational characteristics while allowing traversal behavior to evolve independently of the underlying graph representation.

5. Attach explicit semantics to every edge. Rather than maintaining separate graphs for compliance, debugging, and workflow analysis, we describe each relationship using three dimensions:

  • Type: distinguishes data flow from metadata associations such as views and dataset aliases.
  • Confidence: indicates whether lineage was observed from runtime execution, declared in configuration, or inferred from audit logs.
  • Granularity: identifies whether the relationship was captured at the query, task, or workflow level.

Consumers can select the combination appropriate for their use case. This allows the same graph to support compliance, incident response, debugging, and infrastructure efficiency workflows without maintaining separate copies.

Two Capabilities Beyond Warehouse-Centric Lineage

Spark RDD lineage

Unlike Spark SQL and DataFrames, RDDs execute arbitrary user code rather than exposing a structured query plan, making precise lineage capture more challenging. RDDs remain important for performance-sensitive Spark workloads at LinkedIn. We capture their lineage by instrumenting input and output operations in the Spark integration layer and connecting them at the task level. For arbitrary user code, the platform captures dataset-level rather than record-level lineage, assigns the appropriate confidence, and integrates the relationships into the same graph.

Non-dataflow lineage: VIEW and REFERENCE

Some relationships describe how datasets are represented or referenced rather than how data flows. These metadata relationships are important to compliance, governance, and machine learning workflows.

  • VIEW: A governed logical view over physical tables. Preserving VIEW as a first-class edge type maintains the access-policy context associated with consumer and usage intent.
  • REFERENCE: Connects a Hive table with its underlying HDFS path. Preserving this relationship as a first-class edge allows workloads using either representation to resolve to the same logical dataset.

VIEW and REFERENCE relationships account for roughly 20% of the edges in our production graph, making them important to broad lineage coverage.

Scaling the Rebuilt Platform Across LinkedIn

  • Build a new foundation. As lineage expanded from governance into operational workflows, we designed instrumentation, ingestion, storage, and retrieval together around precise relationships, explicit confidence, and fast traversal. This unified foundation enabled broad deployment across supported platforms in less than six months.
  • Focus on strategic platforms. LinkedIn’s data ecosystem spans dozens of compute engines, data movement tools, and access patterns. We began with widely used platforms, including Spark, Trino, Flink SQL, Beam, Airflow, and Flyte, where native integrations provide high-confidence, query-plan-level lineage. For other systems, declared and inferred signals provide broader coverage with explicit confidence labels.
  • Use lineage to support platform adoption. Teams that move workloads onto these strategic platforms gain more precise lineage, stronger usage visibility, better support for governance workflows, and better tools for pipeline reliability and infrastructure efficiency. These benefits helped adoption of lineage and strategic platforms reinforce one another.

To measure progress, we set a clear rollout goal: end-to-end reachability from business-critical datasets back to their source events and tables. A daily coverage job identifies where lineage chains break, new engine integrations close coverage gaps, automated regression tests prevent regressions, and confidence-rated fallbacks preserve continuity where direct observation is not yet available.

This approach achieved our reachability goal for business-critical datasets across supported data platforms. The production graph now represents roughly 6 million datasets and 10 million edges.

What This Unlocked

Lineage Explorer in DataHub provides an interactive view of multi-hop dataset and job dependencies, turning investigations that once required manual tracing into graph queries that return in seconds. The value, however, is not the graph itself, but the operational workflows it enables.

Trustworthy blast-radius analysis. A single graph traversal returns a current, filtered view of downstream dependencies in seconds, supporting incident response and infrastructure cleanup.

Natural-language lineage exploration. By integrating the lineage platform with internal AI-powered engineering tools, engineers can explore lineage relationships using natural-language questions instead of graph queries.

Final Thoughts

By making lineage a reliable part of LinkedIn’s data infrastructure, teams can better understand how data moves and how changes or failures propagate. This enables safer product development, faster incident response, more effective compliance workflows, and more efficient infrastructure use.

Data databaseperformancepostgresql

pgvectorfast (GitHub Repo)

pgvectorfast improves PostgreSQL vector search performance by replacing the default buffer manager with a faster, lock-free architecture.

Summary

What: The pgvectorfast extension uses a custom buffer pool, Calico, to optimize HNSW graph traversal and vector operations in PostgreSQL 18 and 19. It introduces lock-free optimistic reads and batched asynchronous I/O to reduce contention during high-concurrency vector similarity scans.
Why it matters: It addresses the specific bottlenecks of standard PostgreSQL buffer management during irregular, high-frequency neighbor lookups in large-scale vector indexes.
Takeaway: If you are running large-scale vector similarity searches on PostgreSQL, test your workload using the `zxjcarrot/pgvectorfast` Docker image to see if it reduces your latency bottlenecks.

Deep Dive

  • Replaces the partitioned shared hash table buffer manager with a two-level direct array indexing system.
  • Implements lock-free optimistic reads, allowing vector distance calculations to proceed without atomic pins or content locks.
  • Uses batched asynchronous reads via io_uring to handle large-scale vector lookups.
  • Compatible with existing pgvector SQL APIs and index types like HNSW and IVFFlat.
  • Requires non-LTO compiled PostgreSQL binaries or debug symbols to function correctly.
  • Supports group prefetching to improve CPU cache efficiency during HNSW graph hops.

Decoder

  • HNSW (Hierarchical Navigable Small World): A graph-based indexing algorithm commonly used for high-dimensional vector similarity search.
  • Buffer Pool: A memory region where database pages are cached to minimize expensive disk I/O.
  • Atomic Pin/Unpin: The process of marking a buffer page as 'in use' so it cannot be evicted, requiring synchronous operations in standard PostgreSQL.

Original Article

pgvectorfast

pgvectorfast is a high-performance drop-in enhancement for pgvector that accelerates vector similarity search and analytical queries in PostgreSQL using a fast shared buffer pool.

Based on pgvector, pgvectorfast is a standard PostgreSQL extension on unmodified PostgreSQL 18 and 19 servers for fast vector similarity search. It preserves complete SQL and on-disk compatibility with all pgvector data types (vector, halfvec, bit, sparsevec), distance operators, and index types (hnsw, ivfflat). See the pgvector Documentation for the full SQL API, index parameters, and usage guide.

Benchmark Results

See Detailed Benchmark Results for measured recall, latency breakdowns, and experimental configurations.

How It Works

PostgreSQL's default buffer manager translates every page reference through a partitioned shared hash table and acquires atomic pins and buffer content locks on every page read. Across vector index lookups and analytical scans/joins—and especially during HNSW graph traversal, which performs thousands of irregular neighbor lookups per query—page translation, pin/unpin atomic traffic, and synchronous random I/O become major bottlenecks.

pgvectorfast replaces PostgreSQL's shared buffer manager with the Calico buffer pool (Making Array-Based Translation Practical for Modern, High-Performance Buffer Management), combining three techniques:

  1. Array-Based Page Translation & Path Caching: Replaces PostgreSQL's shared buffer lookup hash table and partition locks on hot paths with two-level direct array indexing backed by lazily allocated virtual memory regions, paired with a per-backend relation prefix cache (~100% hit rate on HNSW indexes).
  2. Lock-Free Optimistic Reads (calico.optimistic_reads): Encodes lock and version state in each 64-bit translation entry so HNSW traversal reads neighbor vectors and computes L2 or inner-product distances (including normalized cosine search) speculatively without atomic pin/unpin operations or content locks, falling back seamlessly to pinned reads whenever concurrent writes or evictions occur.
  3. Workload-Aware Group Prefetch (hnsw.enable_prefetch): Batches neighbor page lookups at each HNSW graph hop to issue parallel translation loads and targeted CPU cache prefetches (__builtin_prefetch) for resident pages (memory-level parallelism), alongside batched asynchronous reads via PostgreSQL AIO / io_uring for non-resident pages (I/O-level parallelism).

Installation

Docker

Pull and run a ready-to-use image for x86-64 (linux/amd64) with PostgreSQL 18, matching debug symbols (postgresql-18-dbgsym), and shared_preload_libraries = 'vectorfast' preconfigured:

docker run -d \
  --name pgvectorfast \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -p 5432:5432 \
  zxjcarrot/pgvectorfast:pg18

Available tags: pg18 / latest (postgres:18-trixie), pg18-trixie, pg18-bookworm, and <version>-pg18 on release tags.

To build the image locally:

docker build --build-arg PG_MAJOR=18 -t pgvectorfast .

APT (Debian)

Prebuilt postgresql-18-pgvectorfast packages for Linux x86-64 (amd64) are published for Debian 12 (bookworm) and Debian 13 (trixie) against the PostgreSQL PGDG APT repository. They declare Conflicts/Replaces/Provides for postgresql-18-pgvector and depend on matching postgresql-18-dbgsym symbols. (Ubuntu PGDG packages compile PostgreSQL with -flto=auto, which Calico rejects at startup because LTO inlines internal buffer-manager routines; on Ubuntu, use the Docker image or build from source against a non-LTO PostgreSQL build.)

  1. Ensure the PostgreSQL APT repository (PGDG) is enabled (for example via postgresql-common / /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh).
  2. Add the pgvectorfast APT signing key and repository, then install:
sudo install -d -m 0755 /etc/apt/keyrings
curl -fsSL https://mitdbg.github.io/pgvectorfast/pgvectorfast.asc | sudo tee /etc/apt/keyrings/pgvectorfast.asc >/dev/null
echo "deb [signed-by=/etc/apt/keyrings/pgvectorfast.asc] https://mitdbg.github.io/pgvectorfast $(. /etc/os-release && echo "$VERSION_CODENAME") main" | sudo tee /etc/apt/sources.list.d/pgvectorfast.list
sudo apt-get update
sudo apt-get install -y postgresql-18-pgvectorfast
  1. Continue with Quick Start to preload vectorfast and enable the extension.

PGXN

Install from PGXN using pgxnclient. Because PGXN compiles from source against your PostgreSQL installation, first ensure you have PostgreSQL 18 or 19 development headers (pg_config), non-LTO server symbols (such as postgresql-18-dbgsym on Debian PGDG, or an unstripped source build), libcapstone-dev (or Python pip), a C compiler, and GNU Make:

sudo apt-get update
sudo apt-get install -y pgxnclient build-essential libcapstone-dev postgresql-server-dev-18 postgresql-18-dbgsym
sudo pgxn install pgvectorfast

If your target pg_config is not first on PATH (or you build as an unprivileged user), pass --pg_config and --sudo:

pgxn install --sudo --pg_config /path/to/pg_config pgvectorfast

Continue with Quick Start to preload vectorfast in postgresql.conf and activate Calico.

Build and Install from Source

Prerequisites

  • Linux x86-64
  • PostgreSQL 18 or 19 with server development headers (pg_config) and non-LTO server symbols: either an unstripped source build or a packaged build with matching debug symbols installed (e.g. postgresql-18-dbgsym)
  • C compiler (GCC or Clang) and GNU Make
  • Capstone (libcapstone-dev 4.x/5.x from system packages, or automatically bootstrapped as capstone==5.0.6 into ~/.cache/pgvectorfast/python-deps via Python pip during make; override with CAPSTONE_PREFIX=/path/to/capstone; must remain available at runtime)

Build and Install

git clone https://github.com/mitdbg/pgvectorfast.git
cd pgvectorfast
make
make install # may need sudo

If your target PostgreSQL installation is not first on PATH, pass PG_CONFIG:

make PG_CONFIG=/path/to/pg_config
make PG_CONFIG=/path/to/pg_config install

Quick Start

  1. Add vectorfast to shared_preload_libraries in postgresql.conf and restart PostgreSQL:
shared_preload_libraries = 'vectorfast'
  1. Enable pgvector and the Calico buffer pool using either approach (as superuser, outside a transaction block):

With one command:

CREATE EXTENSION vectorfast;

Or create the extensions and activate Calico explicitly:

CREATE EXTENSION vector;
CREATE EXTENSION calico;
CALL calico.activate();

After subsequent PostgreSQL restarts, run CALL calico.activate(); to reactivate the buffer pool.

  1. Create an HNSW index and run similarity queries using standard pgvector SQL:
CREATE TABLE items (id bigserial PRIMARY KEY, embedding vector(128));
CREATE INDEX ON items USING hnsw (embedding vector_l2_ops);
SELECT * FROM items ORDER BY embedding <-> '[...]' LIMIT 10;

See the runnable getting-started example and the full pgvector Documentation for all vector types, distance operators, iterative scans, and indexing options.

Configuration

Parameter Context Default Description
calico.optimistic_reads Session / User on Enables lock-free optimistic tuple reads during HNSW traversal for vector_l2_ops, vector_ip_ops, and vector_cosine_ops.
hnsw.enable_prefetch Session / User on Enables batched neighbor group prefetching (CPU prefetch + async read batching) during HNSW search.

Cite pgvectorfast

If you are using pgvectorfast, please cite our work as follows

@misc{zhou2026calico,
  title         = {Making Array-Based Translation Practical for Modern, High-Performance Buffer Management},
  author        = {Xinjing Zhou and Jinming Hu and Andrew Pavlo and Michael Stonebraker},
  year          = {2026},
  eprint        = {2604.00423},
  archivePrefix = {arXiv},
  primaryClass  = {cs.DB},
  url           = {https://arxiv.org/abs/2604.00423}
}
Data databaseperformancecloud

How one SurrealQL query scans 10 billion rows a second

SurrealDB Earth claims over 10 billion rows per second scan throughput by parallelizing query execution across 1,000 Cloudflare Workers.

Summary

What: The architecture splits a single query into 'morsels' (data chunks) processed by stateless worker functions. Orchestration is managed by a tree of 'Durable Objects' that coordinate state, while raw data is read directly from immutable R2 storage files.
Why it matters: This reveals a design pattern for massive-scale distributed databases that leverage ephemeral serverless compute to bypass the throughput limitations of single-node database executors.

Deep Dive

  • Uses a tree-structured fan-out architecture: Executors manage planners, which distribute morsels to Opener Durable Objects, then to Leaf Workers.
  • Leverages Cloudflare R2 for immutable data storage (Runs), allowing any worker to read files without needing to coordinate locks.
  • Implements 'hedging' by assigning slow tasks to additional workers and accepting the first successful response to reduce tail latency.
  • Uses a 'sequencer' to establish a strictly ordered commit history in SQLite-backed Durable Objects.
  • Reads data at a fixed snapshot position to ensure consistency across distributed leaves.
  • Scaling is achieved by adding depth to the tree (more levels of openers) to manage connections, rather than widening a single node.

Decoder

  • Durable Object: A Cloudflare-specific serverless entity that maintains state and allows for consistent coordination across worker functions.
  • Isolate: A lightweight, sandboxed environment for running code, much faster to spin up than a traditional virtual machine or container.

Original Article

How one SurrealQL query scans 10 billion rows a second

SurrealDB Earth reaches more than 10 billion rows a second by splitting one SurrealQL query into many small pieces of work, running them on around 1,000 Cloudflare Workers at the same time, and merging the results into one answer that reads the whole database at a single moment. This post explains each step of that path. Earth launched on 3 November 2026, alongside SurrealDB 4.

What is Earth built from?

Earth runs SurrealDB's own code on four building blocks of Cloudflare's platform:

Cloudflare building block What it is What Earth uses it for
Worker A short-lived, stateless function that runs in its own isolate, a lightweight sandbox Leaves, which read data during a scan
Durable Object A single-threaded object with a fixed identity and its own small storage The executor, the sequencer, the gateways and the openers, which hold state that needs one strict order
R2 Cloudflare's object storage, similar to Amazon S3 Runs, the immutable files that hold the database's data
Colo cache The cache in each Cloudflare data centre ("colo" is short for colocation facility) Keeping recently read parts of runs close to the leaves

A Durable Object and an R2 object are unrelated despite the shared word. A Durable Object is a running program with state, and an R2 object is a stored file.

Everything else in this post is SurrealDB: the query engine, the roles below, the way a scan is cut into pieces, and the checks that make the result correct.

What happens when one query fans out?

A single executor receives the query, runs the SurrealDB engine, and decides whether the scan is too large for one isolate. If it is, the executor cuts the scan into morsels, which are key ranges of the table, and sends them down a tree of openers to stateless leaves.

Each role does one job:

Role Runs as Job
Executor Durable Object Runs the engine, holds the transaction, pins the snapshot, plans the scan and merges the results
Gateway Durable Object Gathers commits from many executors into batches and passes them up to the sequencer, so the sequencer never has to talk to every writer
Sequencer Durable Object Gives every commit its place in one order, and holds recent small commits until they are written to R2
Opener Durable Object Passes a group of morsels to leaves and streams their answers back
Leaf Worker Reads one morsel from R2 and streams back rows or partial results
Run R2 object Immutable, sorted data that leaves read directly

The sequencer holds recent commits in its Durable Object's own storage, which Cloudflare builds on SQLite. That storage is only a short-term holding area for commits before they are written to R2 as runs. The SurrealDB engine runs every query, and the data that a scan reads comes from the runs in R2.

How is the snapshot chosen?

The scan reads at the snapshot of the open transaction, and a reader lease keeps that snapshot available throughout the scan. Before it serves a fresh read, the executor asks the sequencer for its latest position and waits until it has applied every commit up to that position.

The executor then fixes a snapshot position and builds each morsel request from three things:

  1. The key range of the morsel.
  2. The run list at that position, which is every run whose first position is at or below it.
  3. The tail, which is the commits accepted after the last write to R2 and up to the snapshot, limited to the morsel's key range.

Because every leaf receives the same position, the same run list and its part of the same tail, each leaf sees the database exactly as it was at one moment. Commits that arrive after the snapshot are invisible to every morsel. The tail travels with the request, so a leaf never has to call back to the executor for it.

The sequencer keeps a history floor that only rises, and it never lets the floor pass the oldest snapshot that an unexpired lease holds. A scan therefore reads the same runs from start to finish, even while compaction and new commits continue.

How do writes scale?

Reads are not the only part of Earth that grows by adding more of the same thing. Writes take a path of their own, and it is built the same way.

A write starts at an executor, which sends its commit to a gateway. A gateway is a Durable Object that serves a group of executors. It collects the commits from them, checks that commits in the same batch do not conflict, and sends the batch up as one unit. Small commits travel with the batch itself. Large commits are written to R2 once, and only a short record of them moves up the tree.

Gateways sit in levels, in the same way that openers sit between the executor and the leaves. Each level merges the batches from the level below, so the sequencer receives a few large, ordered batches instead of a message from every writer. Adding writers adds gateways, and the sequencer's job stays the same size. Every commit still receives its place in one strict order, so the snapshot rules in the section above hold no matter how many writers there are.

Gateways hold no data that the sequencer or R2 does not also hold, and a gateway that has no work to do holds no connections. A quiet database costs almost nothing, and a busy one takes on more gateways as its writers grow.

What do the leaves do?

Each leaf is a Worker that runs in its own isolate. Earth deploys the same leaf code under many script names so that calls spread over many isolates.

A leaf receives a morsel request on POST /morsel, an internal endpoint of Earth's leaf code. It reads its key range from R2 through the colo cache, merges the tail in by position, and streams the results back with running counts of rows and bytes. An aggregate such as a count returns as a partial result, and the executor adds the partial results together.

How wide does the tree get?

An executor cannot manage a thousand connections at once, so openers sit between it and the leaves. A few limits keep each part of the tree to a size that one object can manage:

  • Each node passes work to at most 32 children.
  • By default, the executor sends work through 6 openers.
  • A read keeps at most 64 R2 requests in progress at once.

To reach more leaves, the tree adds levels instead of making any one node wider. Each leaf takes its next morsel when it finishes one, so a scan can have many more morsels than there are leaves.

How do results merge into one answer?

Morsels cover separate key ranges in ascending order, and together they cover the whole scan range. Verified rows can therefore be released in key order without a sort. Counts add up correctly because every key falls in exactly one morsel and is counted once, from a verified stream.

The executor verifies every morsel before it releases a row. The stream must have consecutive sequence numbers starting from zero, running row and byte counts that match what arrived, and a final frame whose totals equal the rows, bytes and frames received. A stream that is missing, incomplete or inconsistent, or an opener that stops answering, fails the check, and the morsel runs again through another opener.

A morsel gets up to 3 attempts, and each attempt may take up to 8,000 ms. A morsel that never verifies fails the whole scan, so Earth never returns a partial answer.

Slow leaves are hedged. Once every morsel has started, a morsel whose leaf is slower than a threshold is also given to an idle leaf, and the first verified answer wins.

Why does the scan scale with the number of leaves?

Durable Objects hold the state that has to stay in one order. The sequencer gives every commit its place in one order, and the executor holds sessions, the transaction and the dispatch logic. Openers are a pool of Durable Objects that limits how many connections the executor manages.

R2 holds all the data that has been written into runs. Runs never change, so neither the executor's cache nor the colo cache ever needs invalidating, and every leaf reads the same bytes without coordinating with any other. Leaves hold no data and no state, so any of them can stop in the middle of a scan, and the verifier turns that into a retry.

No node owns a part of the data, so adding more leaves needs no data to move. That is why scan throughput grows with the number of leaves while the data stays in object storage.

What do the measurements show?

Measure Result
Table size 5 billion rows
Query SELECT count() AS n FROM t WHERE b < 100 GROUP ALL
Peak rate over 100 ms 22.3 billion rows per second
Leaves reading at the peak 22,085
Best single second 4.55 billion rows
Morsels 24,501
Query wall time 14.5 s

The peak is the best 100 ms window of the scan, not an average over the query. The scan starts its morsels together at a set time, so the load arrives as a burst: the work reaches its peak in about a tenth of a second, and the best full second reads 4.55 billion rows. All of these figures are computed from the leaves' own logs.

Where is the limit, and what comes next?

The executor is the next limit. Each morsel costs about 4 ms of the executor's single thread, which caps a scan of small morsels at about 200 to 280 morsels a second. Planning also takes time, because the executor reads run indexes to decide where morsel boundaries go. The next step is to move planning and the carrying of results from the executor into the node levels of the tree, so that the executor does less work for each morsel.

We are also working on these improvements to Earth:

  • Faster cold starts. A cold start currently takes about 300ms, and we are working to bring that down.
  • Database branching. Branching is coming to Earth, where R2 does much of the work.
Data securityaibackend

Securing Enterprise Data Agents with Policy as Code: A Preflight Gate for Multi-Domain NL2SQL

A new preflight security model secures NL2SQL agents by validating generated SQL dependencies against fine-grained policies before execution.

Summary

What: The approach parses generated SQL into an Abstract Syntax Tree (AST), maps it to specific table/column dependencies, and evaluates these against CEL policies. This prevents shared service accounts from accessing data that should be restricted at the user level.
Why it matters: As organizations deploy data agents, relying on the database's default permissions for a shared service account is a significant security flaw that this pattern attempts to mitigate.
Takeaway: If you are building an AI data agent, move away from shared service accounts and implement an AST-based static analysis step to validate query scope against user-level access policies before submitting SQL to your database.

Deep Dive

  • Parses raw SQL input into an Abstract Syntax Tree (AST) to extract granular access requirements.
  • Evaluates security policies using Common Expression Language (CEL) to verify that the query only touches permitted tables and columns.
  • Dynamically injects row-level filters into the SQL query before execution.
  • Acts as an intermediate 'gate' between the LLM's output and the database engine.
  • Maintains database-native roles as a secondary guardrail rather than relying on them as the primary security implementation.

Decoder

  • NL2SQL (Natural Language to SQL): The process of using LLMs to convert natural language queries into executable SQL commands.
  • AST (Abstract Syntax Tree): A tree representation of the abstract syntactic structure of source code, used by compilers and parsers to understand the logic of a query.
  • CEL (Common Expression Language): A non-Turing complete, high-performance expression language used for embedding policy-based security checks.

Original Article

Shared service accounts can bypass the user-level controls a data agent is meant to enforce. This prototype parses generated SQL into an AST, resolves every table and column dependency, evaluates CEL policies, then prepares approved row filters before execution. Database roles remain the final guardrail. The takeaway: authorize the query's actual dependencies, not just its visible output.

Data infrastructurerustpython

Rethinking Table File Paths with Uber: Lance's Multi-Base Layout

Lance introduces a multi-base layout that allows single datasets to span multiple storage buckets, simplifying multi-region and high-throughput AI workloads.

Summary

What: LanceDB, led by CTO Chang She and engineering lead Jack Ye, added a multi-base path model to its table format. This allows a dataset to reference multiple storage locations by registering 'base paths' in a manifest, preventing the need to rewrite millions of absolute paths when moving data across S3 buckets or storage tiers.
Why it matters: This move highlights a shift in data infrastructure where table formats are evolving to prioritize AI-specific requirements like horizontal throughput scaling, low-latency cross-region serving, and rapid data cloning over the rigid structures of legacy warehouse formats.

Deep Dive

  • The multi-base model uses an array of base paths in the manifest to resolve file locations instead of hardcoded absolute paths.
  • It enables horizontal scaling by distributing data across N storage buckets to increase concurrent read/write throughput.
  • It supports tiered storage, allowing 'hot' data fragments to reside on high-performance storage while 'cold' data remains in object storage.
  • It simplifies disaster recovery by allowing individual data partitions to fail over independently.
  • The system uses a base_id reference in file metadata to reduce manifest size compared to repeated absolute URI strings.
  • The is_dataset_root flag distinguishes between referencing full datasets versus raw storage directories.
  • Designed in collaboration with Uber's AI infrastructure team to handle petabyte-scale multimodal data.

Decoder

  • Table Format: A structural definition for how files (like Parquet or Lance) are assembled into a dataset, including schema, partitioning, and metadata.
  • Shallow Clone: A mechanism that creates a new, lightweight table that references the original dataset's data files without copying the underlying raw data.
  • Manifest: A file containing the metadata and directory of a dataset, mapping the logical state of the table to physical file paths.
  • Object Storage: A storage architecture (like AWS S3) that manages data as objects instead of a file system hierarchy, optimized for massive scale.

Original Article

Rethinking Table File Paths with Uber: Lance’s Multi-Base Layout

The fundamental characteristic of a table format that makes it more than a file format is that it defines how data is assembled. When you look at the architecture diagram of well-known table formats like Iceberg or Lance, you see a hierarchical structure with path references. A top-level metadata file (a metadata JSON for Iceberg, a log + checkpoint in Delta, or a manifest in Lance) links together all the files that comprise the table.

Those arrows in the architecture diagram may look mundane – it’s just “paths” right? But should paths be absolute or relative? Should the format enforce directory conventions or allow files to be put anywhere? These decisions have profound implications for the portability and operational complexity of the format, when applied at petabyte scale.

Those questions became very real when Uber’s AI infrastructure team came to us with a production requirement: distribute a single Lance dataset across multiple S3 buckets to scale throughput, while preserving the portability benefits of relative paths.

Having worked on Apache Iceberg, Delta Lake, and now Lance, I’ve observed this debate play out across formats – and had the chance to help design solutions more than once. This post recaps that evolution and then introduces Lance’s latest step forward: a multi-base path model that, in my view, is the cleanest way to support multi-location storage without sacrificing portability.

The Iceberg Journey: From Absolute Paths to Relative

The original design of Apache Iceberg adopted absolute paths for file references, with a clear rationale behind the decision – absolute paths have the following advantages:

  • No ambiguity: The path s3://my-bucket/warehouse/db/table/data/00001.parquet has no alternate interpretations
  • Flexibility: Files can theoretically live anywhere, even outside the table root
  • Simplicity: Path resolution requires no context; “what you see is what you get”

However, in 2021, the Iceberg community began in-depth discussions about supporting relative paths at the format level. The discussion surfaced a fundamental tension that emerged from real-world usage: absolute paths worked well for static, single-location deployments, but broke down in dynamic, multi-cloud environments. Consider what happens when during table migration. Every metadata file contains thousands (or millions) of absolute paths. Changing the storage location means rewriting every metadata and manifest file, an expensive, error-prone operation that often requires distributed processing jobs to handle such “big metadata”.

Over the last four years, discussions about this feature have repeatedly come up, with vendor-specific solutions like Amazon’s S3 bucket aliases and access points being added to address specific use cases for disaster recovery and data replication. But at the format level, there was little movement.

Finally, in late 2025, the Iceberg community began to align on a design for relative paths in v4. The v4 proposal’s goal is to have zero rewrites to improve portability: when relocating a table (i.e., copying the entire table from one prefix or folder to another), no metadata files need to be modified. This is achieved by making paths without a URI scheme relative, resolving against the table location. The table location can be explicitly specified or derived from the metadata JSON file path. Additionally, the data and metadata locations can be configured to point to a different subfolder or entirely different storage systems.

The Delta Journey: From Relative Paths to Absolute

Delta Lake took the opposite approach, beginning with relative paths. When the protocol specification was first published in September 2019, the definition was as follows: “a relative path, from the root of the table, to a file that should be added to the table”. This meant Delta achieved zero rewrite portability from day one: copy a table directory, and it just works.

However, in August 2021, the protocol was updated to allow absolute paths. The specification now reads:

path: A relative path to a data file from the root of the table or an absolute path to a file that should be added to the table.

This change laid the groundwork for features like shallow clone, introduced in December 2022. Shallow cloning creates a new table that references data files from an existing table without copying them. Because those files sit outside the new table’s root directory, absolute paths become necessary. Delta thus evolved from a purely relative model into a hybrid one – gaining flexibility, but giving up some of its original portability guarantees.

Reflections on the Design

While Iceberg (in the future V4) and Delta are good enough for the zero rewrite philosophy, I found the designs unsatisfying for a few reasons.

The false promise of flexibility

The flexibility of using absolute paths seems compelling: why constrain where files can live? In practice, that flexibility is rarely used – files almost always sit under the table’s root. And once files do span multiple locations, table maintenance gets harder: you can’t safely garbage-collect a directory if its files might be referenced elsewhere. Security features like credentials vending are also typically built around a single prefix so temporary access can be scoped narrowly. Vending credentials for one-off absolute paths across many locations is uncommon across the lakehouse stack, and even when it’s supported, it doesn’t scale gracefully as the number of distinct locations grows.

Zero rewrite, until you can’t

“Zero rewrite” is a good goal, but it mostly holds in the happy path: new tables, a single location, and exclusively relative paths. The moment you introduce operations that rely on absolute references – shallow clones, file imports, tiered storage, or multi-bucket distribution – the zero-rewrite promise starts to crack. What we really want is maximum portability: the ability to move or restructure a table across any distribution topology with the fewest possible metadata changes. No matter what shape a table is already in, relocation should remain simple, fast, and predictable.

Reasoning about file prefixes is hard

The formats ended up with a hybrid approach where some paths are relative and others are absolute. This makes reasoning about path resolution more complex, and increases the surface area for edge cases during migration. Credentials vending is a good example: even if an API (like the Iceberg REST Catalog) can vend credentials for multiple locations, doing it well is difficult because the system has to discover and track all distinct file prefixes across hundreds of millions of file entries in the manifests. And without format-level hints, it’s hard to attach clear operational meaning to those prefixes – or manage them reliably at scale.

Lance: A New Foundation

When I joined LanceDB to work on Lance, it finally felt like we had the right foundation to design from a cleaner foundation. Lance already had two key properties that other formats lacked, listed below.

Predictability over Flexibility

Lance prioritizes predictability rather than flexibility: all files live within a known directory structure, with fixed paths used where possible to minimize manifest size and make path resolution deterministic. Every subdirectory (data/, _versions/, _transactions/, etc.) is defined as part of the format specification.

There is no ambiguity about where files should live.

{dataset_root}/
    data/
        *.lance           -- Data files containing column data
    _versions/
        *.manifest        -- Manifest files (one per version)
    _transactions/
        *.txn             -- Transaction files for commit coordination
    _deletions/
        *.arrow           -- Deletion vector files (arrow format)
        *.bin             -- Deletion vector files (bitmap format)
    _indices/
        {UUID}/
            ...           -- Index content (different for each index type)

Strict Portability

Every path in Lance is relative. A dataset can be copied as shown below and it works immediately – no metadata updates required.

cp -r /local/dataset s3://bucket/dataset

This was a deliberate design choice, driven by the needs of Lance users building AI workflows. AI engineers constantly move data between environments: exploring datasets locally, experimenting with transformations, pushing to cloud storage for distributed training and pulling results back for analysis. This iteration cycle happens on a near-daily basis. A table format that requires expensive rewrites for every move would be a non-starter.

With these two properties in place, the direction was clear. Instead of trying to bolt absolute paths onto Lance, we reframed the problem: “how can we keep paths relative, yet still let a single table span multiple storage locations – without sacrificing maximum portability?”

The Uber Use Case

When Uber’s AI infrastructure team brought us a real production requirement, it became the perfect opportunity to validate Lance’s design principles under real-world pressure.

The need came from their multimodal AI workloads: horizontal bucket distribution to scale throughput. The goal was to distribute a single Lance dataset across multiple buckets – so writes spread across them and reads can fan out in parallel.

At petabyte scale, with thousands of concurrent readers accessing the data during model training and agentic search, a single bucket quickly would become a bottleneck. Uber’s goal was to distribute one dataset across N buckets, effectively multiplying aggregate throughput by N.

Writes round-robin across the set of data buckets: as new data is appended, the system cycles through bucket‑1, bucket‑2, …, bucket‑N to distribute files evenly. Reads then fan out across all buckets in parallel. The challenge was representing this in the table format with minimal disruption to existing Lance features. With absolute paths, portability suffers; with purely relative paths, you can’t reference files outside the dataset root. Uber needed both: multi-location storage with maximum portability.

Lance’s Multi-Base Layout Specification

Uber’s use case gave us the opportunity to design something more complete than the status quo. Rather than patching in a one-off solution, we wanted to address a broader gap in open table formats and move toward a principled model for multi-location storage. The missing concept was a location base.

In practice, when a table contains absolute paths, those paths almost always share a small number of common prefixes. Whether the source is file import, shallow clone, or multi-bucket distribution, the number of distinct “bases” stays small—even when the table references millions of files. By making that shared base explicit in the format, and letting file references point to a base plus a relative path, the rest of the design falls into place:

  • Controlled flexibility: You get multiple locations for a table, but with explicit structure. No more scanning millions of file paths to discover what locations exist.
  • Maximum portability: When you need to port or restructure a table, you update the base paths, not every file reference. Distributing a dataset with 10 million files across 5 buckets means changing 5 strings, not 10 million of them.
  • Composable portability: You choose which bases to relocate together. Keep the primary dataset portable while external references point to their original locations, or migrate everything at once, or anything in between.
  • Operational clarity: The bases of a table are explicit in the manifest. Features like garbage collection and credentials vending become straightforward: iterate the base paths, not the file list.

Format Specification Details

At table format specification level, Lance manifests now contain an array of BasePath entries:

message Manifest {
  repeated BasePath base_paths = 18;
  // ...
}

message BasePath {
  uint32 id = 1;
  optional string name = 2;
  bool is_dataset_root = 3;
  string path = 4;
}

The is_dataset_root field determines path resolution behavior. When true, the base path is treated as a Lance dataset root with standard subdirectories (data/, _deletions/, _indices/). Resolving a data file under this path would mean to add data/ to the base, and then the data file relative path. When false, the base path points directly to a file directory without subdirectories. This distinction enables two use cases: referencing complete datasets (for use cases like shallow clones) and referencing raw storage locations (for multi-bucket distribution like Uber’s setup).

Each file references its base via a base_id, for example:

message DataFile {
  string path = 1;             // Relative path within the base
  optional uint32 base_id = 7; // Reference to BasePath entry
  // ...
}

message DeletionFile {
  optional uint32 base_id = 7;
  // ...
}

One important additional benefit to call out in this design is its storage efficiency compared to storing absolute paths. Each base path absolute URI appears exactly once in the base_paths array, regardless of how many files reference that location. Individual files store only a small integer base_id (1 byte for up to 128 bases in protobuf varint encoding) instead of repeating the shared path prefix. This ensures the table manifest is small and continue to be efficient to load in a multi-base situation.

Uber’s Multi-Bucket Lance Dataset

Here’s what Uber’s multi-bucket setup looks like with this design:

s3://bucket-1/dataset_root/      (primary dataset root; is_dataset_root: true)
├── data/
│   ├── fragment-0.lance
│   └── fragment-1.lance
├── _versions/
│   └── 1.manifest               (contains `base_paths`)
└── …

s3://bucket-2/                   (data bucket; base id: 1; is_dataset_root: false)
├── fragment-2.lance
└── fragment-3.lance

s3://bucket-3/                   (data bucket; base id: 2; is_dataset_root: false)
├── fragment-4.lance
└── fragment-5.lance

The primary dataset root in bucket-1 keeps Lance’s standard directory layout and versioned manifests. The additional buckets (bucket-2, bucket-3) hold only data files, with no Lance subdirectories. All locations are registered in the manifest’s base_paths, and each fragment points to its storage location via a base_id.

Working with a Multi-Base Lance Dataset

To make this more concrete, let’s look at a Python example showing how to create and write to a multi-base dataset:

import lance
from lance import DatasetBasePath
import pandas as pd

# Create a dataset with multiple data buckets
data = pd.DataFrame({"id": range(1000), "value": range(1000)})

dataset = lance.write_dataset(
    data,
    "s3://bucket-1/my_dataset",
    mode="create",
    initial_bases=[
        # Register additional bases for the dataset that will be created
        DatasetBasePath("s3://bucket-2", name="bucket2"),
        DatasetBasePath("s3://bucket-3", name="bucket3"),
    ],
    target_bases=["bucket2"],  # Write this particular batch to bucket2
)

# Append more data
# Write this batch to bucket2 and bucket3
more_data = pd.DataFrame({"id": range(1000, 2000), "value": range(1000, 2000)})

dataset = lance.write_dataset(
    more_data,
    dataset,
    mode="append",
    target_bases=["bucket2", "bucket3"],

# Add a new base
dataset.add_bases([
    DatasetBasePath("s3://bucket-4", name="bucket4")
])

# Write to the newly added base
new_data = pd.DataFrame({"id": range(2000, 3000), "value": range(2000, 3000)})

dataset = lance.write_dataset(
    new_data,
    dataset,
    mode="append",
    target_bases=["bucket4"],
)

# Reading is transparent - just open the dataset
dataset = lance.dataset("s3://bucket-1/my_dataset")
print(dataset.to_table())  # All 3000 rows, from all buckets

The target_bases parameter controls where new data files are written. When there are multiple bases, all bases are used in a round-robin fashion. Reads automatically span all registered bases.

Unlocking New Use Cases

Hot-tiering with high-performance AI storage

AI training clusters often pair cloud object storage with high-performance systems such as parallel file systems (e.g., Lustre) or specialized AI object stores (Weka, Nebius, CoreWeave). These tiers can deliver much higher throughput and lower latency for GPU training, but they live at different locations than your primary cloud bucket.

Multi-base makes it straightforward to stage “hot” fragments onto these fast tiers and switch storage backends without changing the table’s structure. You can copy frequently accessed fragments to the high-performance system, register that location as a base path, and let training jobs read hot data from the fast tier while cold data stays in cost-effective object storage.

Multi-region distribution for localized AI training

Global AI deployments need data close to compute. Training clusters in different regions should read from local storage to maximize GPU utilization, and inference endpoints need low-latency access to embedding data for real-time serving. Traditional approaches often rely on complex replication pipelines or vendor-managed multi-region systems.

With multi-base, a single dataset can span regions natively. Training jobs in us-east read from us-east storage, while inference services in eu-west query eu-west replicas. You avoid cross-region transfers on the hot path, minimize operational overhead, and keep data access aligned with where compute runs.

Efficient disaster recovery for localized AI serving

Disaster recovery is critical for AI serving at the edge. If data in a region becomes unavailable, semantic search quality and agent performance can degrade immediately, impacting end-user experience. Fast failover to a healthy replica in an available region is essential.

For datasets stored in a single default location, Lance’s relative paths already provide simple disaster recovery: replicate the dataset and open it from the backup location.

Multi-base extends that simple approach to multi-location datasets. When a table spans several bases, you can fail over each base independently. If one region goes down, you update only the affected base path to point to its replica, while the other bases continue serving from their original locations.

Shallow clone, branching and tagging for AI experimentation

Multi-base also serves as a key foundational building block for Lance shallow clone, branching and tagging, a feature that many ML and AI engineers love for their experimentation workflows.

For example, a shallow clone references data from a source dataset via a base path while maintaining its own modifications. The clone can append data, modify schemas, or delete rows independently. Only the manifest and new data files exist in the clone location; the source dataset remains unchanged.

Acknowledgments

This work wouldn’t have been possible without the support of the Uber AI Infrastructure team, who provided feedback, helped implement the features in Lance, and validated them at production scale. Special thanks to Jay Narale, who drove the implementation across Rust, Python, and Java, along with comprehensive testing for concurrent writes, conflict resolution, and edge cases.

This collaboration is a great example of how format evolution should work: real production requirements for modern AI workloads shaping the specification, backed by robust implementations that prove the design in practice.

Design ai

AI is the New Old Design Material

Designers should treat AI models as a material that yields a distribution of results, necessitating bulk sampling and failure analysis during review.

Summary

What: The process involves running prompts 50 times to capture the spread of possible outputs, treating failure cases as shared artifacts for the design team.
Why it matters: Treating AI as a static tool misses the inherent variability of models; treating it as a stochastic material requires new quality assurance workflows.
Takeaway: Run your core prompts at least 50 times to map the 'range' of model outputs before finalizing your design system.

Deep Dive

  • AI outputs are not fixed results but probability distributions.
  • Designers must shift from manual creation to curation and testing of model variance.
  • Storing 'failed' outputs serves as a valuable library for testing prompt robustness.
  • Repeated sampling reveals the limitations and 'personality' of an AI model.
  • Design reviews should focus on the quality of the model's output distribution, not just a single successful prompt result.

Decoder

  • Stochastic: Processes involving a random probability distribution or pattern that can be analyzed statistically but not predicted precisely.

Original Article

Designers have always learned their medium by working it, and AI models are the next material. A mockup shows one sample, while a model returns a distribution of answers that only sampling code reveals. Running each prompt 50 times, bringing the worst answers to design review, and saving failures as shared test cases puts that spread in front of the team.

Design frontendcareer

Your path to design engineering

Design engineering is a discipline of ownership where the practitioner solves design problems while taking responsibility for their actual implementation.

Summary

What: Karl Koch outlines tailored learning paths for designers and engineers, emphasizing that design engineering requires moving beyond prototypes to managing real-world constraints like error states and data loading.
Why it matters: The gap between static design tools and production code is closing, making 'design engineers' critical for bridging the handover void.
Takeaway: If you are a designer, build a functional form that handles validation errors; if you are an engineer, practice redesigning a component's visual hierarchy.

Deep Dive

  • Design engineering is defined by taking responsibility for both the design solution and the code implementation.
  • Frontend engineers should practice 'design judgment' by analyzing typography and hierarchy before opening an inspector.
  • Designers should move beyond static screens by implementing state logic like validation and error recovery.
  • The most effective way to learn is to work on small, complete projects that include error handling and keyboard accessibility.
  • Use AI to explain code you don't understand, but perform the implementation changes manually to ensure comprehension.
  • Projects should be shared early to invite critique on both the visual and behavioral trade-offs.

Original Article

I’ve written about becoming a Design Engineer a few times, and the advice gets awkward when I try to give everyone the same starting point. An engineer who’s spent years shipping interfaces needs something quite different from a designer opening a codebase for the first time. Someone who’s just graduated might still be figuring out which part of the work they enjoy.

You bring something useful with you in each case. I’d start there, then look for the part of making a product that you currently need someone else to figure out.

For me, design engineering means being able to work through a design problem and take responsibility for its implementation. You can lean towards either discipline, and you’ll still need to ask for help along the way. What matters is understanding the decisions well enough to explain them, change them and deal with what happens when somebody uses the thing.

This is a little choose-your-own-adventure guide to practising that. Pick the closest starting point, even if your job title says something else. The exercises here focus on web interfaces so that you can try them in a browser and share the result easily.

You’re coming from frontend engineering

You already know how much happens after someone says a design is “done”. You’ve dealt with content that doesn’t fit, slow requests, missing states and components that have to work in places their author never imagined. That’s useful design knowledge, even if you haven’t been calling it that.

The next step is to get involved before the solution is settled. When someone gives you a screen to build, ask what the person using it needs to accomplish and which decisions are still open. Try proposing an alternative in the medium you know best. A small working comparison can make a conversation about hierarchy or behaviour much more concrete.

You’ll need to practise seeing, too. Pick an interface you think works well and explain why. Where does your eye go first? Which spacing decisions group related things? What changes when the copy gets longer? Rebuilding it can help, but spend time understanding the decisions before reaching for the inspector.

Build your foundations: redesign one decision

Take a settings form you’ve built, or make a small one with a name field, a notification preference and a save button. Keep the functionality fixed and make two versions of the layout. Change the grouping, type hierarchy and wording to make the consequences clearer.

Ask a designer to compare them with you. Be specific: “Can you tell which setting affects email?” is more useful than “Does this look good?” Then ask someone to use it without your explanation. Notice where their reading order differs from the one you intended.

Keep the working form and a short note about what you changed after the feedback. Try to connect each visual decision to something the person understood or managed to do. If all you can say is that it looks cleaner, there’s probably a bit more of the reasoning to work through.

Stretch your practice: own the brief

If you already make those visual decisions comfortably, take on a small problem before anyone has designed the answer. Find a confusing interaction in the product you work on and agree with your team what improving it would mean. That might be helping people recover from an invalid setting without losing their changes.

Write a short brief, build two plausible approaches and ask a designer and an engineer to challenge them. Choose one based on what you learn, then follow it through review and delivery. Keep the scope small enough that you can stay involved in the details.

Show the original problem and the alternatives you tried, including why you left one behind. That gives somebody else a way to follow how you arrived at the finished form.

You’re coming from design

You already have practice turning an ambiguous problem into something people can understand and use. Keep bringing that to the work. Learning to build will give you a way to test decisions that are difficult to settle in a static screen: how a layout responds, what happens during a request, or whether an interruption makes the interface confusing.

Start with a small piece of UI and follow it further than you normally would. A form is a good candidate because it quickly forces you to think about behaviour. Where does the data live while someone edits it? What happens if saving fails? Which element receives focus after an error?

Learn enough HTML, CSS and JavaScript to understand your answers. You can use AI to explain unfamiliar code and help with an implementation, but keep changing things yourself and checking what happens. If a suggested fix works, ask why the original broke and whether you could recognise the same problem elsewhere.

Build your foundations: make the states real

Design and build a small profile form. Start with labelled inputs and a button, then add validation, a saving state and a success message. A simulated request is fine for this exercise; make it possible to trigger a failure deliberately so you can design the recovery too.

Use the form with a keyboard. Try a narrow screen and a very long name. Make sure an unsuccessful save leaves the person’s edits intact. Ask an engineer to walk through your code with you, especially the relationship between the form’s state and what appears on screen.

Your deliverable is a working form with a short explanation of how it behaves. You should be able to change a validation rule, explain why the save button is available or unavailable, and trace an error back to its cause. Those are useful signs that you’re beginning to own the implementation.

Stretch your practice: work inside an existing product

If you can already build a convincing prototype, find a small improvement you can make in an existing codebase with the team’s agreement. Reuse its components and conventions. Work with its real data and error handling, and ask an engineer to review it as they would any other contribution.

This is where the interesting constraints show up. Your preferred interaction may conflict with an existing pattern. A component might serve several screens. You might discover that an apparently visual change affects keyboard navigation or the order in which data arrives.

Stay with the change through review, release and any fixes it needs. Keep a note of what changed from the prototype, because those are often the parts you’ll learn the most from and want to be able to explain later.

You’re starting out

You don’t need to decide your entire career before you’ve had a chance to try the work. If you’ve recently graduated, or you’re changing direction, a small complete project can help you discover which parts hold your interest and which ones you want help with.

Choose a problem close enough that you can speak to someone who has it. It could be finding the right room for a society meeting, keeping track of equipment you’ve lent out, or working out what information belongs in an event signup. Keep the first version deliberately small. One useful flow gives you plenty to learn.

Sketch it, build it, then watch someone try it. You’ll get more from that loop if you resist adding features until you understand what happened in the first version. A person hesitating over your carefully chosen label is excellent material to work with.

Build your foundations: finish one useful flow

Make a signup form for a fictional event. Explain who it’s for, what attending involves and what happens after submitting. Use HTML and CSS first, then add the JavaScript needed to validate the form and show a confirmation. Clearly label it as a demo so nobody expects a real booking.

Try it on your phone and with a keyboard. Ask someone to sign up and tell you what they expect to happen next. Revise the wording or behaviour where their expectation and your implementation disagree.

Keep the first version as well as the improved one. Write a short account of the problem, what you learnt from showing it to someone and what you changed. You now have a piece of work you can discuss in detail, including the bits you still need to learn.

Stretch your practice: invite a constraint you didn’t choose

If you’ve already built a few projects, make your next one involve another person’s requirements. Agree a small, low-risk contribution with a club, a community project or an open-source maintainer. Establish who will review it and look after it afterwards. If that isn’t available to you, ask a peer to write a brief and review what you make.

Work within an existing visual language or codebase. Share your work before it feels finished, explain your trade-offs and respond to the feedback. You’ll practise something that solo projects can avoid: making a good decision when other people also have a stake in it.

When you write it up, say which parts you owned, what you reused and where you had help. I’d like to understand the contribution well enough that we can talk through the decisions together.

Where the paths meet

Whichever route you take, give yourself a small enough piece of work that you can follow it all the way through. Explain the problem, make the design decisions, build the behaviour and check it with someone else. If you get stuck, that’s useful information about what to learn next.

Give yourself time for the less glamorous parts too. Long content, empty states, failed requests, keyboard access and maintenance all need some attention.

This is also where experience changes the next step. If you already do all of this, you may get more from helping a team do it consistently. Improve a shared component, make review easier, or pair with someone who’s learning the part you know well.

If a little structure would help

You can work through every exercise here independently. A colleague who gives thoughtful feedback, the documentation for the tools you’re using and a project you care about will take you a long way.

Once you’ve made something, take a bit of time to work out what you’re comfortable taking responsibility for now and where you’d still want help. It gives you somewhere useful to start the next conversation, whether that’s with a teammate, a mentor or somebody hiring.

Design frontend

Design Engineering Has a Handoff Problem

Unregulated AI-generated components are creating a new maintenance bottleneck for engineers due to poor code quality and lack of architectural governance.

Summary

What: Designers providing inline SVGs and hardcoded values are forcing engineers to perform significant cleanup, effectively shifting rather than solving the handoff problem.
Why it matters: The current toolchain fails to enforce engineering standards on design-led AI outputs, leading to a accumulation of technical debt in frontend repositories.
Takeaway: Implement deterministic linting and code quality checks on all incoming design-generated components before allowing them into the review queue.

Deep Dive

  • The core issue is a lack of governance over designer-submitted code.
  • AI-assisted generation currently bypasses standard architectural review processes.
  • Inline SVGs and hardcoded styles are the primary sources of friction.
  • Engineering should demand the same merge standards for designers as they do for other engineers.
  • Teams must provide designers with lighter, sandboxed environments to experiment with code safely.

Decoder

  • Handoff: The process of moving a project from the design phase to the implementation phase by engineering teams.
  • Deterministic check: A code verification process that produces the same output given the same input, often used in CI/CD pipelines to enforce quality.

Original Article

AI-generated components from designers were meant to lighten engineers' load, but ones with hardcoded values and inline SVGs now pile up in engineers' review queues. The handoff has simply moved down a level, with designers lacking the governance, permissions, and shared tooling engineering built over years. The fix starts with holding designer code to the same merge bar, running deterministic checks before human review, and giving designers a lighter environment.

Design aipolicy

Artists and creators are leaving Etsy in droves over its new AI policy

Etsy creators are exiting the platform in protest of new terms that authorize the company to use seller content for training AI models.

Summary

What: New terms of use effective December 16, 2026, grant Etsy and its third-party partners the right to use seller content to 'develop, train, test and improve artificial intelligence and machine learning technologies.' Despite VP James Ossman claiming this will not be used to 'copy' original work, the policy lacks a general opt-out mechanism.
Why it matters: This incident highlights the growing friction between centralized marketplaces and independent creators regarding data ownership and the use of user-generated content for proprietary AI model training.

Deep Dive

  • Etsy updated section 5 of its terms of use to include specific authorization for AI and machine learning training on seller content.
  • The platform recently attempted to curb 'AI slop' (low-quality, AI-generated listings), making the subsequent change in terms particularly contentious.
  • Many sellers are responding by closing their stores or directing customers to personal websites or niche marketplaces like Folksy.
  • Etsy's leadership maintains that AI usage will focus on fraud detection, search improvement, and seller tools rather than generative imitation.
  • Sellers currently have no universal mechanism to prevent their product photography and descriptions from being used in these training sets.

Decoder

  • AI Slop: A derogatory term for low-quality, automated content generated by AI models that clutters platforms and devalues human-made work.
  • Scraping: The automated process of extracting large amounts of data from websites, often used to build datasets for training AI models without explicit permission.

Original Article

You might be suffering whiplash if you've been watching things at Etsy lately. Just a couple of weeks ago, things looked tentatively hopeful for the marketplace as Etsy promised to crackdown on AI slop. Now creators are fleeing the platform in droves because of its own AI policy.

Creators have largely welcomed Etsy's decision to ban listings by bots and to insist that product photos resemble the actual product being sold – surely a rule that all marketplaces should implement. But new wording in its terms of use has caused alarm over how content could be used for AI training. As a result, the best website builders could be about to see an influx of custom from artists and crafters.

For years, Etsy has been one of the best places to sell art and design online, particularly handmade craft items, from jewelry and gifts made with Cricut machines to illustration and poster design. But like many platforms, it's faced the problem of quality products being drowned out by AI slop and copied art posted by bots.

Shortly after updating its content rules to try to get on top of that, Etsy's also updated its Terms of Use. The new text adds a clause that has echoes of the policies introduced by certain social media platforms.

Section 5 already included a perpetual licence allowing Etsy to reproduce, modify, distribute and create derivative works from user content. The revised policy now adds a specific authorisation that reads: "This also includes the right for us and our third party partners and vendors to use Your Content to develop, train, test and improve artificial intelligence and machine learning technologies, including to improve the Services and/or help keep them safe, subject to any applicable opt-out rights described in our Privacy Policy".

The new terms come into effect on 16 December, and they've sparked an exodus from the platform. Many creatives have taken to social media to announce the closure of their Etsy stores, using flyers and goodbye letters created in their signature art styles.

Some speak of wrestling over a decision that they fear could harm their business in the short term. Others who have yet to take the leap say they feel trapped because they depend on Etsy as their main source of income and the update has come at the most important time of the year for sales.

Like with Cara for social media, alternative specifically anti-AI marketplaces like Marmalade Handmade or UK-based Folksy, but they remain small compared to Etsy. Some sellers say they can't leave the platform yet but are taking the step of writing to customers to ask them to shop with them directly instead of using the platform.

What do Etsy's AI terms mean?

In an update on the Etsy Community site this week, VP of Customer Operations James Ossman stressed that sellers retain ownership of their creative work on Etsy that the company was focusing on using AI to support sellers and improve the Etsy experience.

He writes: "We do not use your content to train AI models designed to copy your original work or replace your creativity. Again, this is not changing. Our goal at Etsy has always been to connect you and your unique items with buyers."

He provided some examples of how the platform is training AI, including to identify potentially fraudulent accounts and related listings, to understand inventory, to help buyers find items and tailored recommendations and to build tools to help sellers run their businesses more efficiently.

He said Etsy uses security tools to detect and limit unauthorised scraping, while its terms prohibit unauthorised use of marketplace content for AI training. However, he doesn't specify whether authorised partners can use seller content to train models for applications unrelated to Etsy, and the platform has not provider a general opt-out mechanism for sellers who don't want their content used for AI training.

It may be that sellers have nothing to fear, in which case Etsy should really have tried to find a better way to communicate the update. It's aware of the sensitivity around AI, and it's natural for sellers to be frightened by the language in the new terms at a time when AI is being used to clone artists' work in a multitude of fields, from illustration to video game development.

Are you concerned about Etsy's AI policy? Let us know in the comments.

AI research

Genie 4

Google expanded Project Genie to include Genie 4, allowing users to build and edit interactive 3D worlds via real-time natural language prompts.

Summary

What: Genie 4 is available to Google AI Ultra subscribers, featuring real-time environmental editing, native audio generation, and a community gallery for remixing user-created worlds.
Why it matters: This represents the integration of world-simulation models with generative agents, suggesting a future where digital environments are constructed on-the-fly rather than pre-rendered.
Takeaway: Google AI Ultra subscribers can access the project via the Project Genie website; Pro members can join the waitlist.

Decoder

  • World model: A type of generative AI trained to simulate the physics and visual environment of a 3D space.

Original Article

Genie 4 is now available

Earlier this year we introduced Project Genie, an experimental research prototype that lets you generate and explore interactive worlds. Early testers told us they wanted deeper control over what happens inside those worlds, and easier ways to build and share them.

So today, we are rolling out a new Project Genie experience to eligible Google AI Ultra subscribers, making these worlds far more responsive, creative, and social. This update unlocks first-time access to Genie 4, new upgrades to Genie 3, the Project Genie agent which helps users build their vision, and a community gallery to discover, explore, and remix worlds.

Project Genie brings together our most advanced world models alongside our Gemini models, empowering you to generate, step inside, and shape worlds directly from your browser.

Experience Genie 4 in Project Genie

With Genie 4, our most realistic and interactive world model yet, you can now prompt mid-session to change the world you created. Just type a new prompt while you navigate your world and you can edit your environments in real time. Shift the weather, drop in a character, or redirect the action. For the first time, Genie 4 pairs these visuals with real-time native audio that adapts as the scene unfolds, from ambient soundscapes to character dialogue.

Discover new Genie 3 capabilities

While Genie 4 delivers our highest-fidelity visuals, physics, and native audio, Genie 3 remains available in Project Genie’s model picker when you want longer runs or panorama-seeded spaces. Today’s Genie 3 updates include:

  • Extended sessions and world chaining: Explore for up to 3 minutes per generation (up from 60 seconds), or link multiple worlds together for longer journeys.
  • 360-degree panorama image grounding: Seed new worlds from 360-degree panorama images.
  • Real-time in-world events: Dynamically change the environment with natural-language prompts while you explore.

Genie 3 uses real-time promptable events to connect different worlds into one continuous flight across forests, underwater ruins, and icy seas.

Create new interactive experiences

The new Project Genie agent takes creation beyond a single text or image prompt. Now crafting an interactive universe is as effortless as having a conversation. Simply describe your vision in natural language, and the agent orchestrates Google’s suite of multimodal models to craft initial visuals establishing your world’s signature look, paired with custom background scores tailored to the mood.

You can also bring Gemini models into the session as you explore: it observes what is happening on screen, surfaces context-aware suggestion chips for where to go next, or triggers in-world events automatically as your journey unfolds.

Explore the new gallery

When you just want to jump straight into exploring, the new Project Genie gallery brings together a rich collection of curated worlds alongside creative work from the community. Transform personal photos into explorable spaces in “Living Memory,” wander through rich prehistoric habitats grounded in 360-degree panoramas in “Dino Field Guide,” or pit themed objects against one another on a desk with Gemini serving as your real-time referee in “Rock Paper Scissors.”

The gallery also showcases inspiring collaborations with pioneering creators who had early access to these tools. Teaming up with creative technologist Will aka BLVCKL!GHT, we created “Villa Giallo,” an atmospheric, room-by-room mystery inside a gothic manor. And with filmmaker Anand Gandhi, we built “The Life of Ants,” inviting you to navigate a complex colony from an ant’s perspective, drawing on Genie 4’s stunning photorealism.

Beyond exploring curated worlds, you can also launch your vision with a simple prompt or remix existing gallery experiences alongside the Project Genie agent — tweaking the underlying world structure, soundtrack, or rules to make it uniquely your own. Once you’ve crafted something special, publish your creation to the community gallery for others to explore and remix.

Learn how we are building responsibly

We are committed to developing and rolling out interactive world models responsibly. All video and audio generated in Project Genie includes SynthID watermarking, and all model inputs and outputs go through safety screenings.

Genie 3 and Genie 4 remain world models in the frontier research space. As the research continues to evolve, we are actively tackling key challenges such as camera latency, intricate physical interactions, real-time audio precision, and long-term scene permanence. For a deeper look into model limitations and our progress on these fronts, read our Genie 4 model research overview.

Try Project Genie today

Eligible Google AI Ultra subscribers can try the new Project Genie experience starting today, and Google AI Pro members can join the waitlist on the same page.

AI research

An update on the state of research acceleration at OpenAI

OpenAI reports that its AI agents now autonomously complete nearly half of two-to-four-hour research tasks.

Summary

What: OpenAI researchers noted that while agent usage for complex research is growing, humans remain essential for safety, alignment, and guiding the development process.
Why it matters: This reveals a shift from using LLMs as simple chatbots to deploying them as active research agents capable of multi-step, hours-long workflows.

Original Article

OpenAI's agents now complete nearly half of two-to-four-hour research tasks on their own. However, humans are still central to AI development. Agent use is surging, and the heaviest users are pulling further ahead. Researchers are devoting increasing human effort to Safety and alignment.

AI policy

Quickly, There's No Time

The rapid acceleration toward autonomous AI R&D suggests superintelligence may arrive as early as next year, necessitating a shift in safety strategy.

Summary

What: The article argues that we must anticipate the full automation of AI research and development, urging the development of mechanisms to cap or slow down capability growth.

Original Article

Many things point to the substantial possibility of superintelligence arriving next year. Any plan to prepare for this has to be ready for the full automation of AI R&D, which will result in the rapid advancement of AI abilities beyond human levels. It will need to include mechanisms to slow down the resulting growth in capabilities.

AI policy

The Silent Consensus

Dean Ball warns of a 'silent consensus' where we inadvertently surrender human authority to autonomous AI systems through market logic and automation.

Summary

What: The author argues that companies and institutions are increasingly incentivized to replace human managers with autonomous agents, leading to a world where humans are passengers in their own civilization.
Why it matters: This highlights the tension between economic efficiency and the retention of human agency in an era of superhuman capabilities.

Original Article

The Silent Consensus

Against Forfeiture

Today’s essay is adapted from a lecture I gave recently as part of the Vik-Bailey Lecture series at Harvard. I thank my hosts for their hospitality. This post reflects my own views, and not necessarily the views of OpenAI or any of its other employees.

Thank you for being here today. As we speak, one of the most significant sets of cybersecurity events in history is happening, a set of critical security vulnerability disclosures that some are calling “Black October.” These vulnerabilities, which were found in some of the core infrastructure of the internet, were found by frontier AI systems, and their disclosure is part of an urgent effort to bolster software security worldwide. This is the urgent matter this month; next month there will be another. Software vulnerability discovery is the dual-use capability AI systems have arrived at today, but soon enough there will be another, and it will inspire its own urgent project to use the good side of the capability before malicious actors use the bad side. All of these urgent matters will overlap, inevitably, and much of what we today call “AI policy” is likely to be made amid this clamor.

But it is not the reactive and urgent things I’ve come to talk to you about today. Instead, I want to talk to you about where things might be headed in the bigger picture. It can be hard, amid such a barrage of urgency, to think about these more abstract and airy questions. But these questions matter, because without a sense of what long-term futures we’d like to achieve–and which we’d like to avoid–we might end up with a macro outcome we disfavor, even if we made wise decisions at every step along the way.

It is often remarked that the technology industry lacks a positive vision for where the things it is building will take us. I disagree: San Francisco and other hubs of entrepreneurship are filled with positive visions for our technological future. People really are building flying cars, autonomous vehicles, robots of many sizes and shapes, nuclear fusion, and, of course, artificial general intelligence. What we lack, instead, is a positive vision of our institutional future: how is this all going to work?

That is not to say, however, that there is no institutional vision for the future. Unfortunately, the vision I find most common is not one I would call positive. When it is articulated at all, it is usually in whispers. But more often, it is left unsaid, discernable only by implication. I call it the silent consensus.

Consider a company that can do almost everything without human labor. Its AI systems do research and development, make discoveries, negotiate contracts, allocate capital, and manufacture. Suppose it is better at these things than its human competitors, even when those humans augment their effort with AI. If human involvement serves only to slow the business down, human managers and owners will have a powerful incentive to take their hands off the wheel. If this occurs throughout the global economy, humans will be driven by the logic of market competition to forfeit their primacy over global commerce. Over time, the market may come to serve the demands of machines as much as, or more, than it serves the demands and wants of people.

What happens after that is anyone’s guess. Perhaps humans would benefit tremendously. If the machines who had subsumed us held humans in high intrinsic regard, we could become the beneficiaries of their labor and the wealth they generate. Or perhaps, being robbed of economic and increasingly political power, humans will find ourselves less and less relevant in the world, less and less able to shape the trajectory of world affairs. Maybe a small number of humans would hold extraordinary power and wealth, at the expense of a broadly disempowered mass, or maybe we all would share the same fate of disempowerment. Regardless of the specifics, the common thread that constitutes the silent consensus is the termination of human primacy in the world as we know it.

Nothing in these scenarios requires AI to rebel against its creators. Nothing requires its owners to wish for human disempowerment. Each decision to delegate can make sense on its own terms. Yet taken together, the decisions could produce a world in which people have forfeited effective authority over much of our civilization. Even if we make extraordinary progress on the bedeviling questions of AI safety and alignment, we could still find ourselves having submitted to a new kind of machine entity. In the happy version of the future, the silent consensus would tell us, that entity will be a kind one, a machine with the best interests of humans at heart. A machine, the Brautigan poem goes, of loving grace.

To these machines, the silent consensus tells us, we will hand over the keys to our companies, and more and more, our institutions of governance. They will run them more effectively, more efficiently, with better wisdom and better judgment than we humans can muster. And so we will, with time, take our hands off the steering wheel, and let the loving machines take over the driving. We will be like passengers in a car—a very nice car, perhaps a materially nicer car than we can dream of today—but passengers nonetheless, lacking control over where the vehicle is headed. To the extent that we work, it is mostly as a kind of ritual or play-acting, something more like a game to entertain our species.

Some observers will argue that the silent consensus rests on a false premise, because we humans do not control the world today to begin with. And this criticism is worth bearing in mind: there is no “we” who decides what to do. We live in a radically decentralized world, whether we like it or not. Yet this point should not make us complacent either: while “we” do not “control” the world, human beings collectively do have primacy over world affairs. There is no species of animal that seriously competes with us for control over resources. We should reject the intellectually sloppy notion that humans can exercise top-down control over the world, but we should not conflate that rejection with a denial of the obvious reality that humans are, collectively, the Earth’s prime actor.

Some people who are willing to articulate the silent consensus believe it is a genuinely good future. Others do not, but are resigned to its inevitability. The silent consensus is not a consensus because everyone agrees it is good, nor is it a secret plan among the people building AI. The consensus is simply that the forfeiture of human primacy over world affairs is inevitable, or at least that it is very difficult to imagine another vision for a future that is truly robust to superintelligent machines. A person can sincerely oppose that outcome while finding it difficult to conjure a plausible alternative vision. The fact that the consensus is mostly silent, sotto voce at best, is the tell.

I despise the silent consensus. I reject the forfeiture of human primacy. I detest the sense of inevitability. I remind myself that I could not look at my baby son in his beautiful eyes if I submitted to the silent consensus. And so to the silent consensus, I say no. And I believe the time has come to speak openly about the silent consensus, to shake ourselves out of our mostly unwitting acceptance of this vision.

The problem is this: the silent consensus became consensus for a reason. It is difficult to describe how humans will remain at the steering wheel alongside vastly superhuman machine intelligence. Most attempts to do so rely on arguments that AI is a mere tool, an instrument of pattern recognition not capable of “genuine understanding.” I fear these arguments are not robust to the reality of what is coming. I fear that they are their own form of complacency—a position based mostly in denial of what AI can do rather than a belief rooted in an affirmative vision for a human-led future. AIs cannot be said to lack “genuine understanding” even as they come to make progress on intellectual problems whose solutions have eluded humans for decades and centuries.

Why, then, do I believe humans must retain primacy? The easy answer is because I am a human being, and I am indeed an unapologetic human chauvinist.

But there is something deeper, too. Our primacy rests not in our intellect, not in maintaining our monopoly on “genuine understanding” indefinitely into the future. Our primacy rests instead on our past.

For it is we who came up out of the mud. We who forged primitive society out of dirt and stone. We who gazed up at the stars and asked why. We, with our fighting and our love and our envy and our joy, who discovered morality and ethics and law. It is we who sang and danced, wrote and composed. It is we who made history, and it is we who wrote it. That legacy is ours. The civilization we have built is a flame we have tended, and that flame belongs to us. Our past is a glorious inheritance over which we all are stewards, and part of that stewardship is our participation in what Michael Oakeshott called “the conversation of mankind,” that grand endeavor that began in primeval times.

Through that long and winding past, we forged a civilization that, in America, was conceived with the rights of the individual at the foundation, with reverence for the paths we all forge as we make our way through the world. Human beings have lives that can go better or worse: we bear the fruit of our wise decisions, and we bear the consequences when we err. The right to walk one’s own path does not turn on being the cleverest or the wisest. I do not lose my standing as a citizen because my neighbor has better judgment. I see no reason that the arrival of a more intelligent machine should dissolve that standing either, and indeed I see every reason to prevent that dissolution from occurring.

Some may argue that the machines, having read nearly the entire written record of this inheritance, are heirs too. And in some sense, they are. But a person who has read every letter in your family’s attic does not somehow become a member of your family. AI systems will come to join the conversation of mankind, first as observers and increasingly as participants, but they must not dominate it, nor render that conversation moot. To cede primacy is to betray our ancestors just as much as it is to betray our progeny. If this is not a fight worth having, no fight is worth having.

Now, I happen to believe that the adherents of the silent consensus are wrong about what machine superintelligence will be. That they are missing something important about how the world works, that they conflate intelligence with power. If you described the capabilities of even today’s AI systems to an adherent of the silent consensus five or ten years ago, they would probably have predicted that joblessness would be much higher now than it in fact is, and that human disempowerment writ large would be far further along than it actually is. I believe that human collective intelligence and capability is far greater than the adherents of the silent consensus suppose, and that our societies will prove more robust than they predict.

But I could be wrong. It may simply be the case, for example, that fully autonomous corporations outcompete human enterprise altogether. And if that is true, then the raw logic of economics will dictate that more and more capital be handed over to the machines. Disempowerment, in this future, does not require a machine overthrow of human civilization; it simply requires that the logic of capitalistic enterprise continue apace. Here, the AI revolution would find its closest analog in the agricultural revolution, when new modes of production fundamentally changed the architecture of human society. That this transformation was pleasant for the humans who experienced it is far from clear; indeed, there is substantial evidence that this transformation worsened human wellbeing for millennia.

I do not know if this is the future we face, and indeed I have argued elsewhere that I do not believe it is. But many of my colleagues—smart and caring and conscientious people—believe this is likely to be our future. If they are right, our fight against the silent consensus will be all the more challenging. We will have to swim against the current of economics, and in so doing, reject many of the things that are dogma for classical liberal individualists like me. This will be a perilous endeavor, one in which failure is far from improbable. But if this is not a fight worth having, no fight is worth having.

Retaining primacy means retaining accountability for humans and human institutions. That means AI developers should be accountable when they engage in unsafe development practices, but it also means that people and firms using AI should be held accountable when it is their misuse or lack of oversight that causes harm. This requires not just the law, but the technical infrastructure of accountability. People must be tied to the actions of their agents, and agents untethered to a human–if they are to be permitted at all to engage in the legitimate economy–must do so under guardrails. Any ability for agents to autonomously form corporations, own property, or litigate should be granted with extraordinary caution, if at all.

And in my industry, we can start to think seriously about how to build intelligent machines that are compatible with human primacy. We can build agents whose permissions are intelligible and limited, whose actions can be audited, and whose authority users can withdraw. Accountability for actions that materially affect others need not entail surveillance of ordinary private life or the end of anonymous speech. We can make commitments to user privacy and individual sovereignty over their digital property and data, including the practical ability to take that data elsewhere. We can design systems that help people acquire understanding and make decisions, as well as systems that carry out tasks. And we can test whether the products we build leave their users more capable of acting in the world.

None of this is a complete blueprint for a society with superhuman intelligence. I would distrust anyone who claimed to possess one. But it is a place to begin.

The future is shrouded in a thick fog. But we can still act today. Collectively, we can, for one thing, name the silent consensus aloud, expose its contours to the light of day. We can, each of us, radically widen the scope of our ambition. We can choose not to let AI shrink us, and instead do the hard work of letting it enlarge us. We can learn to ask ever-bolder questions, to interrogate the world with new verve and ferocity, and to wield our powerful machines in so doing. We can become a new kind of man—not a transhuman, but a man expanded.

I think about this when I look at my baby son. I do not wish for him merely to be watched over by benevolent machines, however comfortable a life they might provide. I want him to inherit a world in which he can ask questions no one has thought to ask, build things no one has thought to build. I do not want him to have a nicer car with a plusher passenger seat. I want him to have the wheel.

AI agents

Inside the Codex sandbox

OpenAI's Codex sandbox enables coding agents to execute commands directly on a user's machine within predefined file and network constraints.

Summary

What: The sandbox environment allows developers to grant autonomous agents permission to run local commands, provided they stay within specified, user-defined boundaries.
Why it matters: This indicates a shift toward 'agent-in-the-loop' development, where AI assistants move from just generating text to performing actual system-level execution under human supervision.

Original Article

The Codex sandbox lets OpenAI's coding agent run commands on a user's own machine within file and network limits the user controls.

Tech hardwaremobile

A Tesla Model Y Without A Steering Wheel Is Coming

Tesla is developing a steering-wheel-free version of the Model Y designed to transport groups of up to seven passengers autonomously.

Summary

What: Tesla aims to produce a dedicated autonomous vehicle (AV) that eliminates traditional driver controls like pedals and steering wheels. While development is underway for this group-transport focused Model Y, standard models with traditional controls will remain in production.
Why it matters: This signals Tesla's pivot toward purpose-built robotics rather than just retrofitting consumer vehicles, likely targeting the ride-hailing market segment dominated by companies like Waymo.

Deep Dive

  • Plans focus on a fully autonomous variant of the existing Model Y platform.
  • The design removes all manual driver interfaces: pedals and steering wheels.
  • Capacity is intended to be 6-7 passengers for shared transport use cases.
  • Tesla will maintain production of traditional Model Y vehicles with controls for individual owners.
  • This shift reflects broader industry trends toward Robotaxi fleet optimization.

Original Article

Tesla plans to create a fully autonomous vehicle that can seat more than two people. It is developing an autonomous version of the Model Y without a steering wheel or pedals. The vehicle will be designed for transporting groups of people and will be able to seat up to six or seven passengers. Tesla will continue to manufacture regular Model Ys with steering wheels for the foreseeable future.

Tech opensourceagentsdevops

Foundation Software

Maintainers should pivot from managing upstream pull requests to mining forks, as AI agents make it easier to maintain personal patches than ever.

Summary

What: Jacob Tomlinson proposes that instead of forcing every niche feature into upstream projects via pull requests, developers should publish personal forks. Maintainers can then use AI agents to analyze these forks for recurring patterns to decide which features are broadly useful enough to upstream officially.
Why it matters: The rise of 'vibe coding' and AI-automated rebasing means maintaining a custom fork is no longer a major burden, potentially shifting open source collaboration from centralized PR management to a distributed, exploration-based model.

Deep Dive

  • Open source projects are seeing an influx of AI-generated PRs that are often low-quality or niche.
  • Maintaining personal forks is becoming easier due to AI-automated rebase and cherry-pick tools.
  • Suggests a paradigm shift: fork projects for personal needs rather than requesting merges.
  • Maintainers can use agents to scrape community forks to identify high-interest features.
  • Shift focus toward modular design and good 'agent instructions' (AGENTS.md) to facilitate easier customization.

Decoder

  • Vibe coding: An informal term for using LLMs to generate functional code or entire applications through conversational prompting, often without deeply understanding the underlying mechanics.
  • Upstreaming: The process of contributing patches or features from a local branch back into the main, official repository of an open-source project.
  • Rebase: A Git command that moves a sequence of commits to a new base commit, often used to keep a local branch up to date with the latest changes in the upstream project.

Original Article

People are not just vibe coding all sorts of side projects from scratch, they are forking the existing tools they use and are building on top of that code too.

I’ve found myself doing this a bunch recently. For a long time I’ve run a home server where I self host lots of different applications. Sometimes I notice a gap in that project, whether it’s a bug, a missing feature, whatever. In the past for bugs and general purpose features I would probably fix them and make a PR upstream. However if I wanted something personal, niche or unusual I just wouldn’t bother. The upstream project almost certainly wouldn’t accept that PR and the effort required to maintain a fork against upstream was too big to be able to justify. But with agents it’s easy not only to generate the feature I want but most importantly I can have a recurring job that rebases my changes onto new releases or just cherry picks fixes from the main branch.

There’s something powerful about feeling ownership over the software you use. This feels like the true vision of open source.

It’s clear that 2026 has been a weird year for open source. On one hand there is more code on GitHub than ever, and the constant stream of open AI models coming out of labs around the world has empowered many developers. On the other hand many projects have closed their PRs and taken an anti-AI stance, while other communities have seen a huge drop in interest because it’s easier to just vibe your own.

I find it interesting to think about the future of open source software. Despite the rumours it’s certainly not dead, but it will be different. Libraries are more important than ever because agents can use them as building blocks to quickly flesh out their codebases (but they may be cribbed, vendored or used as reference more). While at the same time simple projects like habit trackers or meal planners are being vibe coded almost daily because they are simple and often very personal pieces of software. Lots of Reddit communities I am a part of don’t allow submitting vibe coded projects because there are so many and there is so much duplication.

I don’t want to spend my time rebuilding things that already exist. Of course I could build a document manager from scratch, but I would much rather use paperless-ngx with some customisation to make it behave the way I would like and leave my agents to keep my fork up to date with the community. As a result instead of looking for the best solution to a problem I have I’ve started looking for the best foundation software for me to build my own solution on top of.

I want to use projects which have:

  • Good agent instructions in their AGENTS.md
  • Helpful skills for running tests, verifying new changes, etc
  • Good modular design and layout so my agents can navigate it quickly
  • Clean records of how things work and the reasoning why in developer documentation (for example ADRs)

The better these things are the more likely my agent is going to generate clean code when it makes changes instead of slop.

As we shift in this direction as a community it begs the question “what about upstreaming contributions?”. I have hundreds of commits of code sitting in my forks which I will never upstream. In some ways I kinda feel sad about that, I like giving back and I like making software better for everyone. But at the same time I know that people won’t want my niche and specific changes.

Instead I think we need to flip the paradigm. We should publish these forks and share them, put them online for everyone to see, but with no expectation of merging. There is huge value in sharing our weird and wonderful tweaks. But instead of opening a PR and requesting someone to consider merging it the maintainers can just explore all the forks to find trends. As a maintainer of software projects I would love to be able to poke around and explore all the forks that people make. I would be able to send my agents off into the various worktrees hunting for patterns. Are there things that get modified frequently in the same way? If so we should consider making that same change upstream. Are there things that are frequently changed but in a myriad of different ways? If so we should consider making that component even easier to customise.

In her talk All Code Is Slop (Except Mine) Lauren Tan compares building software with agents to tending a garden. Sometimes you need to just let things grow and then cut them back. You need to put the frames and structures in place to help guide and propagate the plants you care about. I enjoy Lauren’s analogies (her Michelin Kitchen one is great too) but the garden one got me thinking. Lots of people have gardens. They can be very personal places where you explore and experiment and make things just the way you like. We don’t often tend a communal garden, we usually let our local authority manage our parks and other green spaces, and that’s ok. It’s ok to grow your own garden and enjoy it yourself, just like it’s ok to build your own software for your own use. When we have a garden we often show it to our friends and families. Avid gardeners may also visit stately homes or other places with show gardens to learn and get ideas. We should do more sharing without the expectation of adoption. Sharing and discussing still builds community.

I feel like we are entering a golden age of building software. The barrier to entry for building and customising things has gotten a lot lower. But I don’t want to spend my time rebuilding things that already exist. I want to spend my time tailoring my software to my needs and building new things and I would much prefer to have a solid foundation to build on top of.

Tech startupcareernvidia

Nvidia interim CEO Kress tells employees ‘let's move forward' at first all-hands meeting since Jensen Huang exit

Nvidia executives attempt to stabilize internal morale by moving up pay reviews while explicitly ruling out the return of former CEO Jensen Huang.

Summary

What: Interim CEO Colette Kress and board chair Harvey Jones addressed staff at an all-hands meeting, confirming that yearly reviews and pay raises are moved from March to December. Despite employee requests to reinstate Jensen Huang, the board stated it has no intention of doing so.
Why it matters: The leadership is attempting to decouple Nvidia's organizational stability from the cult of personality surrounding its former founder as the company navigates post-exit uncertainty and a 37% stock price drop.

Original Article

Key Points

  • Nvidia executives addressed employees Wednesday at the first all-hands meeting since Jensen Huang resigned.
  • “Let’s move forward,” Nvidia interim CEO Colette Kress told the room, according to a person in the room who spoke to CNBC on the condition of anonymity.
  • Kress also mentioned pay raises for employees, according to the person.

Interim Nvidia CEO Colette Kress told employees "let's move forward" on Wednesday during the company's first all-hands meeting since founder Jensen Huang resigned, a person who attended the meeting told CNBC. The person asked not to be named because the meeting was private.

Kress was joined by newly appointed board chair Harvey Jones and hyperscale and high-performance computing head Ian Buck.

Several other senior members of Nvidia's executive team spoke or joined Kress on stage, including longtime company veteran Jeff Fisher, senior vice president of software engineering Dwight Diercks, senior vice president of GPU engineering Jonah Alben, executive vice president in charge of operations Debora Shoquist and co-founder Chris Malachowsky, according to people familiar with the matter.

Kress opened with the message about moving forward and also mentioned pay raises and explained that the yearly review process, when employees typically get pay raises and are granted more stock, would be moved up from March to December. Nvidia shares are down 37% from their 52-week high.

Jones discussed the search for the next CEO, the person who attended the meeting said. The meeting lasted about an hour and was in person as well as streamed on Microsoft Teams.

The general sentiment swirling in the room, according to the person, was that employees want Huang to come back. Employees have spoken up on X in recent days to call for the return of Huang as CEO, and one senior employee reportedly sent a letter to the board warning Nvidia would lose "irreplaceable talent" if it doesn't consider reinstating Huang.

But another person familiar with the matter disagreed, saying that employees welcomed the remarks from leadership as well as the visibility into company leadership. The person asked not to be named because the matter is private.

"The Nvidia board unanimously accepted his resignation and does not intend to reinstate Jensen as CEO," Jones said during the company's earnings call on Tuesday.

Some executives shared that they do not agree with Jones. "Why make such a strong definitive statement when the investigation is still playing out," an employee told CNBC. The employee asked not to be named given the sensitivity of the subject.

The meeting was held one day after Huang said he was ready to return as CEO should the board want him. Multiple employees told CNBC that Huang's letter "fired employees up."

Despite recent turmoil, Wednesday's meeting was not out of the ordinary. Nvidia typically holds all-hands the morning after quarterly earnings reports, according to a former employee, who asked not to be named because the matter is private. Kress recapped Tuesday's earnings report, calling it a "great quarter," according to the person who said employees welcomed the remarks and visibility from leadership.

In past meetings, Huang took time to answer questions submitted by employees, according to the former employee. A person familiar with the matter told CNBC that the executives also answered pre-submitted questions in Wednesday's all-hands.

Nvidia shares were down Wednesday, a day after the company reported third-quarter earnings that topped Wall Street expectations and gave no signal that the company was going to slow its growth.

Tech policyaitransportation

On Waymos and their safety record

Waymo’s safety claims are a corporate policy tool that shifts responsibility from democratic institutions to an unaccountable entity with a profit-driven 'safety dial.'

Summary

What: Critics argue that Waymo’s safety data relies on non-comparable statistics and masks the reality that autonomous systems are programmed to prioritize cost-efficiency over absolute safety.
Why it matters: This challenges the tech-industry narrative that self-driving cars are an objective societal upgrade, suggesting instead that safety standards are arbitrary and subject to change based on corporate market-share goals.

Original Article

Long-term, there is little incentive for self-driving car companies to prioritize the safety of road users like cyclists. They can eat any amount of fine payments. They can bring any amount of legal influence to bear. It is simply not wise to allow this kind of power imbalance between road users! I think the threat of a tech company becoming a road user is, long-term, greater than the benefit of automatic driving.

This is a really good point I hadn't really considered myself, although I also generally oppose "autonomous" vehicle deployment by corporations for a few related but distinct reasons.

The first one is that I think safety claims from companies like Waymo need to be treated with extreme skepticism; tech companies lie basically all of the time about basically everything, so they're probably lying about this. Don't tell me they wouldn't do pivot to video with people's lives.

But beyond outright lying, many of the claims are just misleading.

The crux of the article is a comparison between the crash rate of Waymos and the crash rate of "all drivers", which as far as I can tell from Waymo's own descriptions of their methodology, means all drivers in US counties that Waymo operates in.

These comparisons inherently require statistical adjustment to approximate an apples to apples comparison, because Waymos are just not driving the same routes that human drivers are; in particular, they do very little highway driving, which is significantly more dangerous than city driving—per the US DoT, rural driving has about a 50% higher fatality rate per distance traveled.

Waymos are also, you know, Waymos—small minivans and crossovers, all electric, all pretty new, all very inherently safe. We're comparing this to the median American car, which is an SUV with a fetish for rolling over or a pickup truck with a fetish for running over children.

Waymo has published peer-reviewed papers about their safety record—all in the same journal. It's worth questioning whether anyone with a real incentive to interrogate their methodology is in a position to do so. Everyone in power is kind of broadly incentivized to go along with Waymo's claims. Auto makers want a new market for cars; policy makers want a convenient tech solution to road safety problems that doesn't require them doing work or the state spending money. The idea that self-driving is extremely safe is extremely convenient, which is itself a reason to be skeptical.

It's also worth saying that by far the most convenient way for Waymo to exaggerate their safety record is this: Waymos are not always operating autonomously; they are often being guided by remote operators, whom the company will not refer to as "drivers" for liability reasons. Whatever Waymo says about when exactly or how often those remote operators are in control is, of course, something that Waymo gets to disclose or lie about with total impunity; it's not independently verifiable.

The way Waymo talks about road safety is also designed to induce in the reader and overestimation of the safety gain from Waymos. A large proportion of road accidents is caused by either drunk driving or speeding. If you're walking into a rideshare or taxi vehicle with a presumably sober driver who isn't going to drive recklessly, you are already significantly safer than the average person on the road, so the broad comparison Waymo is making is exaggerating what the safety gap is in specific circumstances.

The conversation also inherently marginalizes questions of what things we could do to promote road safety that are not giving over control of the road to one of the world's most evil corporations. How would Waymos compare to human drivers who were being more effectively induced to drive safely through traffic calming and other infrastructure that generally isn't being adopted by cities in the Americas?

However, all of this is just pointing out that Waymo is almost definitely exaggerating their numbers and presenting them in a very rosy light; even so, you might look at the actual numbers and say "well, it's such a huge difference, there's definitely a meaningful benefit there."

Here's the problem with that. One reason Waymos are very safe because they drive extremely conservatively. For this reason, they are also slow and will sometimes get "stuck" when they can't determine a safe way forward. This approach to driving is a good idea for Waymo right now, when they're trying to gain regulatory acceptance for their vehicles in more and more cities.

But let's say Waymo captures significant market share. Let's say a large city, or several large cities, actually do become meaningfully dependent on Waymo for transportation. Being slow makes Waymos uncompetitive against other modes, and it makes the service costlier to operate.

On a self-driving vehicle operated by a corporation, road safety is a dial. It's something Alphabet just gets to turn up or down depending on their goals. If Waymo ever becomes established as a significant transportation provider, very soon after there'll be a meeting in a dark room in Mountain View where they'll decide, for all of those cities they're operating in, what an acceptable level of road fatalities is. What an acceptable level of cyclist-car collisions is. That number probably looks pretty similar to the number that policymakers throughout the US, Canada, and Latin America tend to think is acceptable right now, given the degree to which cars are tacitly allowed to kill people. They'll turn that dial until it hits that "acceptable" equilibrium, because safety costs them money.

There are no technical solutions to political problems. Waymo cannot solve road safety, categorically; it can only shift the locus of policymaking about road safety, away from the democratic control of state institutions and into an unaccountable, dishonest, and fundamentally evil corporation. In the process, the seduction of easy technical solutions can only harm progress towards real policy change.

To think Waymo is a solution to road safety is a trap. You are talking about buying safety from an entity that has zero commitment to human life.

Tech enterpriseai

We Need Smart People Who Give a Shit

Fragile global systems rely on 'smart people who give a shit,' and the widespread displacement of these workers by AI is a recipe for catastrophic system failure.

Summary

What: The author suggests that complex infrastructure, like banking and aviation, functions only because humans manually intervene to patch flaws. Replacing these humans with AI models that 'don't give a shit' removes the necessary human oversight and care.
Why it matters: This highlights the 'hot stove' theory of organizational risk: companies must learn by failing that AI output cannot substitute for deep domain knowledge and accountability.

Original Article

🧠 We Need Smart People Who Give a Shit

Something I learned a long time ago, something that's been proven to me time and again, is that the world is held together by smart people who give a shit. This truth always comes into stark focus when I learn how a complex system functions—or, rather, how it barely functions.

When I worked at Stripe I learned a lot about various banking and money movement systems, and it's terrifying how flawed and fragile these systems are. ACH is a great example. It's a complex system we rely on every day that is just barely good enough to function. It's old, riddled with flaws, and encumbered with legacy baggage. And yet, despite all of those problems, ACH usually works great and is generally considered to be safe, cheap, and reliable.

The reason there's a mismatch between the technical reality of the ACH system and how it functions in practice is due to a single factor: smart people who give a shit. Every problem with ACH is fixed, patched, bypassed, overridden, routed around, or manually handled by people who have two things:

  • Intimate knowledge of the system
  • The drive and determination to force the system to work

Those two things feed into each other. You have to care about a complex system to dive deep enough to learn how it works, and when you know a lot about how a complex system works you care more about it, especially if the system is important or critical infrastructure.

Now, you can replace "ACH" above with a myriad of other complex systems—everything from huge infrastructure to nice-to-have apps—and everything I said remains true, both about the systems themselves and the people who keep them running. The world runs on these systems, and they depend on smart people who give a shit. Take those people away, and the systems collapse.

And collapse is what we're starting to see. Some recent examples of various failures from just this past week or so: Microsoft 365, Air Traffic Control, United Airlines' systems, the NSA's network, many major banks, Apple's systems, and more. We're told these failures and problems are not related. They're not the result of a cyberattack. They're not the fault of generative AI.

I guess that depends on how you look at it.

I don't have inside information about what's going on, but my experience dealing with complex systems tells me there's a common through line to all of these disruptions: there aren't enough smart people who give a shit.

So where did they go?

Capitalism has never been particularly kind to smart people who give a shit (or people in general... but I digress). Capitalism does, however begrudgingly, recognize that smart people who give a shit are required to build and maintain complex systems that serve capitalist goals. Thus, those people have been accommodated and incorporated into the system by virtue of their necessity and, in many cases, their rarity.

Now, though, generative AI is here. To the people running the show—leadership and management—it seems like they can get the same or better value (and even more output!) from a machine. The machine is cheaper, works longer, doesn't take sick days or vacations, doesn't ask for any benefits, and never pushes back against a bad idea.

People who don't do the actual work—the people who aren't in the trenches—have a hard time telling the difference between a flawed system held aloft by the drive and determination of smart people who give a shit and slop provided by generative AI. To them it's all just output: words you can read, code that runs, and pixels that look nice to their eye. It's all the same to them, so why does it matter where it comes from?

It matters because generative AI isn't smart, and it doesn't give a shit. What seems like intelligence is an illusion propped up by a massive amount of data strip-mined from the commons with weights that nudge the output toward a generally desirable shape. What seems like care, concern, and attention is just generative AI doing what it's designed to do: telling you what you want to hear. The math and logic that power LLMs are as cold, unfeeling, and indifferent as the laws of physics.

Smart people who give a shit notice things. They connect dots. They notice when things don't feel right. They know when something is about to go off the rails, and they know how to get things back on track. They know how to handle edge cases. They know how to manually handle a unique situation. They know what the right thing to do is, and they know when they need to put in extra effort or time to make something happen. Generative AI falls far short in these areas, but this is the glue that holds complex systems together. More prompting and more output isn't a substitute for this.

It's hard for capitalist leadership to internalize any of that, though. It would be such a relief for them, such a burden lifted, to replace all those smart people who give a shit with generative AI. It would be so much easier to win at capitalism if generative AI lived up to the hype, and there's so much pressure for leadership and management to believe that the hype is real.

Thus, a lot of the smart people who give a shit have been laid off, and the ones that remain are hollowed out. Telling people to stop doing the job they signed up for in favor of babysitting LLMs so they can do that job instead is a great way to make people less smart about the system they used to work on and give less of a shit about it. Every prompt moves them one step further away from the system they used to know inside and out. Every generated output that becomes part of the system means those people understand less about how the system actually works. Those people are robbed of the things that make them smart (the struggle of building and learning) and the things that made them gave a shit (a sense of ownership and close connection with the system).

We've moved from a world dependent on complex and fragile systems held together by smart people who give a shit to a world of complex and fragile systems run by generative AI. The people running the generative AI are not as smart, nor do they give as much of a shit. There are, of course, exceptions (which is why a lot of things are still humming along), but we are on a course where the number of smart people who give a shit are decreasing, and that's a big problem. As long as the number continues to go down, more systems will fail.

I think what we have here is a hot stove moment for capitalism. When you tell a young kid a stove is hot and they shouldn't touch it, you'll find there are two kinds of kids. For one kind of kid, the warning is the lesson, and they don't touch the stove. For the other kind of kid, the only lesson that works for them is being burned. They have to touch the stove at least once to learn the lesson. Capitalism was told the stove was hot, but their hand is on it right now.

Unfortunately, we're all getting burned.

Tech aiagentscareer

Agents are here to stay. How can companies really go faster?

While AI agents radically accelerate individual coding velocity, they do nothing to solve the quadratic scaling problem of team communication and synchronization.

Summary

What: Clément Sauvage argues that as AI increases individual output, human sync overhead—which scales according to the number of communication channels—becomes the primary bottleneck to company speed, effectively limiting the gains predicted by Amdahl's Law and Brooks's Law.
Why it matters: This perspective suggests that the most successful organizations in an agentic era will not necessarily be the ones with the best automation, but those that flatten organizational structures to keep teams small and highly autonomous, reducing the 'sync tax'.

Decoder

  • Amdahl's Law: A formula used to find the maximum expected improvement to an overall system when only a part of the system is improved.
  • Brooks's Law: The observation that adding human resources to a late software project makes it later due to the overhead of communication and training.

Original Article

I disconnect more and more from tech forums, reddit, HN, youtube, etc… but whenever I come back to it, and I face a piece of content about AI agents, there’s still many of those naysayers claiming AI can’t do the coding, the planning, debugging, presenting, or whatever else.

I am not sure if we live in the same world, but AI is definetly a crazy speedup for almost everything.

This actually highlights more than ever the main speed bottleneck we always had: human sync. The bigger the company, the bigger the overhead, as the network of people who need to align keeps growing. Agentic coding and workflows accelerate so many things, but the main bottleneck stays the same, and it might even get worse. If syncing used to eat 50% of the time, it can easily become 90%. The cost is communication.

Amdahl’s law pretty much already stated that, the increase of velocity that can be achieved in a team was already capped by the proportion of the bottleneck, which is most likely going to be meetings/reviews/alignment.

Say execution takes 80% of a sprint and sync takes 20%. Speeding up execution is very impactful. But even if agents bring execution close to zero, the remaining 20% caps your maximum speedup at 5x (1 / 0.20).

Now take a team where sync is 50% of the time. Make execution 10x faster and total time goes from 1.0 to 0.55. That’s a 1.8x speedup, and sync is now about 91% of what’s left. The theoretical cap is 2x, however fast the agents get.

Brooks’s law explains why this gets worse as companies grow. Communication channels scale as n(n-1)/2, so 5 people means 10 channels, 10 people means 45, and 50 people means 1,225. Agents increase what each person produces, but not their ability to align with everyone else. More output per person means more things to sync on, so the quadratic term hurts even more than before.

But enough with the theorical laws, and math to make it sound smart. They were more about explaining the point. Smaller companies have a speed edge, or at least small teams. Settings where people are more autonomous, where agents can iterate on their own. This is where you’re removing the speedup cap that you get when adopting agentic workflows.

And it doesn’t have to come in at the expense of product quality/code quality/architecture/security, etc… No. Now, we see more and more Product Engineer: software engineer who owns the full product cycle, from what to build, designing the user experience, writing the code, measuring the user impact, etc… and even maybe defining a big picture direction. These will probably become the norm.

Data databaseenterprisecloud

MongoDB Acquires Firebolt

MongoDB has acquired Firebolt to embed a high-concurrency analytics engine directly into its database platform.

Summary

What: The acquisition aims to integrate Firebolt's analytical engine into MongoDB’s Intelligent Data Platform. This setup intends to eliminate the 'data-movement tax' by keeping analytical data synced with operational data in real-time, targeting sub-second query performance for AI agents and live applications.
Why it matters: It represents an industry push to collapse the distinction between transactional (OLTP) and analytical (OLAP) database workloads for real-time AI agents, moving away from traditional ETL-heavy architectures.

Decoder

  • Data-movement tax: The operational cost, complexity, and latency penalty of copying data from operational databases into separate data warehouses for analysis.
  • OLTP (Online Transaction Processing): Databases optimized for fast, transactional record updates.
  • OLAP (Online Analytical Processing): Databases optimized for complex, read-heavy aggregate queries.

Original Article

Real-time analytics on live operational data, built so applications and AI agents can act on what’s happening now.

The most valuable analytics no longer live in a dashboard. They live inside the application. A logistics app reroutes a shipment around a delay. A retail system reorders inventory before the shelf goes empty. A payments platform flags unusual behavior before the transaction clears.

Each of these decisions requires comparing live operational data against historical patterns. Which routes are backing up, and is that normal? What’s selling faster than usual, and should we restock? Is this login typical for this account at this time of day? Enterprises that can answer these questions in the moment adapt as conditions change. Those that can’t are reacting to yesterday.

Data infrastructure has long been split into two worlds: operational databases that run applications, and data warehouses that analyze what already happened. That paradigm was built for humans looking at morning dashboards, where data a few hours or days old was fine. As analytics moved into applications, real-time analytics emerged as a category of its own, combining complex queries over massive datasets with the speed, freshness, and concurrency that live applications demand. Agents raise the bar on all three. They act continuously, can drive thousands of concurrent queries, and need sub-second answers on fresh data. As businesses rely more on agents, real-time analytics becomes a core part of their data infrastructure.

Eliminate the data-movement tax

Running analytics on operational data often means copying it into a separate system, forcing organizations to build and maintain data pipelines, keep systems in sync, and run yet another platform. Even once the data is flowing, the added complexity, operational overhead, infrastructure cost, and risk of stale answers remain. This is the data-movement tax, and it compounds as agents drive more decisions.

Systems that require customers to move and synchronize data across separate platforms often struggle to deliver fresh answers at the speed and scale that live applications need. For MongoDB customers, the operational data their applications and agents rely on is already in MongoDB, so analytics should be able to run there too, at the source. That's why MongoDB acquired Firebolt.

One platform for operational data and real-time analytics

By integrating Firebolt into MongoDB’s Intelligent Data Platform, we’re bringing a high-performance analytics engine to where your operational data already lives. Firebolt’s engine will run right alongside your database, and we’ll keep it in sync automatically, so there’s no pipeline to build or manage. You’ll get one platform for operational and real-time analytical workloads, so teams can ship faster, with fewer systems to operate and secure.

Our Intelligent Data Platform already brings together operational data, search and vector search, Voyage AI models, stream processing, and the ability to build and run agents in production. Real-time analytics will extend that foundation, enabling applications and agents to analyze live data and act on it in the moment. Over time, customers will also be able to analyze data from other sources and formats alongside their MongoDB data.

When analytics powers a live application, an outage no longer just delays a report. It breaks the customer experience or stalls an agent mid-decision. MongoDB operates in this mission-critical world: today, approximately 75% of the Fortune 100 trust MongoDB with applications that require the highest levels of security, durability, and availability. We’re bringing that same level of reliability and operational excellence to real-time analytics.

Why Firebolt, and what’s next

Firebolt’s analytics engine is proven in production. It was built from the start for the high concurrency required by live applications and agents, not just internal dashboards and reports. Similarweb, for example, uses Firebolt to power complex, customer-facing analytics over more than a trillion rows at petabyte scale, with dynamic queries delivering sub-second performance without extensive pre-aggregation.

Firebolt’s team has tackled some of the hardest problems in analytical engines. CEO Benjamin Wagner’s background is in analytical database research at the Technical University of Munich. He built the Munich engineering team behind Firebolt’s engine and led engineering before becoming CEO. CTO Mosha Pasumansky was an architect of Microsoft Analysis Services, co-invented the MDX query language, and led the technical development of Dremel and BigQuery at Google.

“Firebolt was designed for the cloud to do what many people believed was impossible: low-latency, high-QPS analytics with fast-changing data on object storage,” says Mosha Pasumansky, Firebolt’s CTO. “We also knew that today’s applications deal with complex and flexible schemas, the kind MongoDB’s document model supports natively. So we made sure to keep the benefits of columnar storage and vectorized processing on those schemas through smart automatic column shredding.”

“Firebolt and MongoDB share the same DNA,” says Benjamin Wagner, Firebolt’s CEO. “We both build mission-critical data infrastructure for engineers. We spent the last several years building an analytics engine for what live applications and agents demand: high-concurrency, sub-second answers on fresh data. Joining MongoDB puts our engine where millions of developers already build. We can’t wait to bring real-time analytics to MongoDB customers.”

We’re thrilled to welcome the Firebolt team to MongoDB, and our teams are already working together to bring Firebolt’s engine into MongoDB. In the coming months, customers will be able to turn on real-time analytics for their MongoDB data, so their applications and agents can act on what’s happening now.

More to come soon. Join the waitlist to be among the first to try real-time analytics on MongoDB.

FAQ

What is Firebolt?

Firebolt is a high-performance analytical database designed for low-latency queries and high-concurrency applications.

Do Firebolt and real-time analytics replace a data warehouse?

No. Traditional data warehouses and data lakes remain the right fit for internal BI, reporting, and data science. Real-time analytics is for application-facing analytics, which has a different set of requirements: complex queries over massive datasets, sub-second responses, high concurrency, and fresh data for live applications and AI agents.

What happens to existing Firebolt customers?

Nothing changes for existing Firebolt customers. They can continue using the product with the same support and service. Firebolt’s customers are a big reason we wanted to bring this team and engine into MongoDB. They’ve shown what the technology can do under real production load.

Data databaseopensourcepostgresql

Open Source DocumentDB 1.0 Reaches General Availability

DocumentDB 1.0 is now generally available, providing a PostgreSQL-backed document store that supports the MongoDB wire protocol.

Summary

What: Backed by Microsoft and the Linux Foundation, DocumentDB 1.0 translates MongoDB protocol requests into PostgreSQL calls via an extension and gateway. The release supports PostgreSQL 15–18 and adds a Kubernetes operator for easier management.
Why it matters: This signals a continued effort by major tech firms to commoditize the MongoDB document API while keeping the data locked within the more stable and pervasive PostgreSQL ecosystem.

Decoder

  • Wire protocol: The low-level format and rules used by a client (like a MongoDB driver) to communicate over a network with a database server.

Original Article

Open Source DocumentDB 1.0 Reaches General Availability

DocumentDB 1.0 is the first generally available release of the open source, MIT-licensed document database built on PostgreSQL, with compatibility for the MongoDB wire protocol. Most MongoDB drivers, tools, and queries work without changes.

DocumentDB consists of a PostgreSQL extension that provides MongoDB API-compatible functionality and a gateway that translates MongoDB protocol requests into PostgreSQL calls. Version 1.0 supports PostgreSQL 15–18 through container images, with Linux packages available for PostgreSQL 17 and 18, and includes a Kubernetes operator, with the GA focusing on security, stability, and fixes for indexing, aggregation, and geospatial queries.

Microsoft announced the open source project early in 2025, aiming to provide the developer community with a NoSQL datastore built on PostgreSQL, and offering full visibility into the engine's architecture and implementation. The project joined the Linux Foundation a few months later, with support from other large database organizations including AWS, Cockroach Labs, Google, Snowflake, and Yugabyte. In the recent article "DocumentDB and the MIT License: What to Know Before You Build, Deploy, and Distribute," the team explains how DocumentDB’s permissive MIT license allows commercial use, modification, and hosting without requiring disclosure of proprietary code, contrasting it with MongoDB’s SSPL.

Even if the project provides a page discussing the DocumentDB name disambiguation, covering the open source project, Azure DocumentDB, and Azure Cosmos DB, the community remains perplexed about the choice. In a popular Hacker News thread, user marifjeren writes:

Name it anything else for god's sake. DocumentDB is already what everybody calls Amazon DocumentDB.

With multiple open source options now on the market, Patty Chow, product manager at Microsoft, explains why open-source document databases need multiple implementations to give developers more choice in deployment and infrastructure while preserving compatibility with MongoDB drivers and queries. Chow writes:

MongoDB has given developers a widely used way to work with document data. Familiar drivers and query patterns are worth preserving. Alternative implementations give developers a chance to keep using that knowledge while evaluating different approaches to storage and deployment.

In a Reddit thread, some practitioners raise concerns about current MongoDB compatibility and confusion with similarly named products. User 716green comments:

Compatibility between MongoDB and FerretDB has been absolutely minimal compared to what you would probably expect. I've been a fan of DocumentDB for a long time and I love that Microsoft is supporting FerretDB.

DocumentDB provides the PostgreSQL extensions and its own MongoDB-compatible gateway, while FerretDB is a separate project that uses the DocumentDB extensions as its backend and provides its own MongoDB-compatible interface.

Layerbase recently ran an initial comparison of FerretDB and the PostgreSQL-based DocumentDB using YCSB benchmarks, finding that DocumentDB delivered 20–33% higher read throughput, while FerretDB had lower tail latency for updates in mixed workloads, but noting the results are not conclusive. An open GitHub issue reports higher query latency in DocumentDB 1.0 than MongoDB 9.0.4 across several workloads, but the results have not been independently verified.

The DocumentDB release notes include upgrade paths and known issues. The project plans separate long-term support and development tracks, with its versioning policy still under discussion.

Design aiweb

Google tests sticky citations in desktop AI Overviews

Google is experimenting with 'sticky' source citations in AI Overviews that remain visible while users scroll through desktop search results.

Summary

What: The feature keeps citation links anchored at the top of the AI response area as the user moves down the page, separated from organic results by a horizontal divider.
Why it matters: This is a direct response to usability feedback that users lose track of information sources in long-form generative AI answers.

Original Article

Google is testing a new desktop AI Overview interface that keeps source citations visible as users scroll through AI-generated answers. The citations move with the content instead of disappearing offscreen, making it easier to access supporting websites while reading longer responses. The experiment also introduces a horizontal divider separating the AI Overview from conventional search results, and the design has been spotted across multiple browsers.

Design aienterprise

Spotify's New Tool Aims to Stop Deepfakes from Being Attributed to Real Artists

Spotify has launched 'Artist Profile Protection,' a tool allowing musicians to manually vet and remove unauthorized AI-generated releases from their profiles.

Summary

What: The feature follows a successful eight-month beta and enables artists to set automated holds on new uploads appearing under their name to combat deepfake music.
Why it matters: The surge in AI-generated 'voice clones' and unauthorized tracks forced Spotify to move beyond reactive takedowns toward proactive artist control.

Decoder

  • Deepfake: AI-generated media that impersonates the likeness, voice, or style of a real artist without their authorization.

Original Article

Spotify is rolling out Artist Profile Protection to all artists, letting them review and remove releases submitted under their name after an eight-month beta. Artists get alerts when new music appears under their name, and an advanced setting holds releases until they manually approve them. The launch follows Billboard's report that Sony Music sought removal of more than 260,000 deepfake songs from digital platforms.

Design frontendreact

Rare Animated React Components (Website)

Rare UI provides an open-source library of specialized, motion-heavy animated React components for developers looking to add polish to their interfaces.

Summary

What: The collection features pre-built, reusable UI elements focused on complex animations, built specifically for the React ecosystem.

Original Article

Rare UI is a free, open-source collection of rare animated React components.

Design frontendreact

React Loaders for Generative UI (Website)

Generative Loaders offers a set of specialized React components designed to provide visual feedback during text, inline, and image generation tasks.

Summary

What: The site provides animated loading states that specifically address the UI requirements of generative AI applications.

Original Article

Animated React loaders for text, inline, and image generation states.

Design ai

Free, Installable Design Systems for Agents (Website)

Design.how offers a repository of installable design systems specifically tuned to help AI agents like Claude Code and Cursor maintain consistent product aesthetics.

Summary

What: The library includes design patterns modeled after platforms like Stripe, Vercel, and Notion that can be installed via CLI to standardize agent output.
Why it matters: As developers move toward agentic workflows, standardizing the visual language of AI-generated code is becoming necessary to prevent UI fragmentation.
Takeaway: Use the provided CLI commands to import system designs directly into your agent-assisted projects.

Original Article

Give agents consistent product taste!

Free, installable design systems for agents. Each one installs with one command.

Design research

Prevent UX Theater with Cross-Functional Collaboration

UX theater occurs when teams perform rituals of research without incorporating actual user needs into the product development process.

Summary

What: The author argues that genuine collaboration between researchers, designers, and developers is the only way to replace superficial processes with evidence-based decision-making.
Why it matters: Performative design processes often mask internal misalignment by prioritizing deliverables over outcomes.
Takeaway: Shift team focus from workshop outputs to direct user feedback and shared accountability for specific product outcomes.

Decoder

  • UX theater: Performing design tasks or research activities that lack meaningful impact on the actual product or user experience, serving mostly to appease stakeholders.

Original Article

UX theater occurs when organizations perform design activities without meaningfully involving users or allowing research to influence decisions. Cross-functional collaboration can help counter this by bringing designers, researchers, developers, and other stakeholders into shared discussions about user needs and product priorities. Meaningful collaboration requires teams to move beyond workshops and deliverables toward evidence-based decisions, shared accountability, and genuine participation in the design process.

Design ai

AI's Role in the Creative Process

Madeline Stafford argues that while AI can automate tedious labor like VFX cleanup, high-level creative friction remains essential for human-centric output.

Summary

What: The author discusses the use of Seedance 2.5 and Weave to create a Gaussian splat campaign, noting that finishing work still requires significant iterative, human-driven effort.
Why it matters: As AI tools become ubiquitous, the value of the creative process shifts from raw production to the quality of editorial judgment and iteration.

Deep Dive

  • AI can successfully handle low-level repetitive tasks like green-screen cleanup.
  • Strategic friction in the creative process is where human quality is added.
  • Tools like Seedance 2.5 require substantial human riffing to reach professional standards.
  • Success depends on the maker's taste and ability to judge the final output.
  • AI should be viewed as a tool for labor-intensive steps, not as a replacement for the full creative workflow.

Decoder

  • Gaussian splat: A method for representing 3D scenes using millions of tiny 3D gaussians, often used in modern photorealistic rendering.

Original Article

Full article content is not available for inline reading.

Read the original article →

Design animation

Disney's Radical New Animation Technique Will Make Hexed the End of an Era

Disney is abandoning its uniform 3D house style for a new pipeline that allows for varied, project-specific visual identities starting after the film Hexed.

Summary

What: Chief Creative Officer Jared Bush confirmed that all original Disney feature films following the November 25, 2026, release of Hexed will utilize a new hybrid animation pipeline. This technology blends 3D models with 2D hand-drawn elements, exemplified by the upcoming short Lilo & Scratch, which incorporates original watercolor backgrounds alongside new digital assets.
Why it matters: Disney is attempting to counter audience fatigue with generic, 'same-face' 3D animation while moving away from the expensive and often unpopular live-action remake formula. The new pipeline balances the efficiency of 3D production with the aesthetic flexibility of hand-drawn art.

Deep Dive

  • Disney is shifting to a hybrid animation model that maintains 3D spatial depth while applying unique artistic 'looks' to each film.
  • The new workflow is designed to be more efficient than traditional 2D animation while avoiding the perceived homogeneity of modern 3D.
  • VFX supervisor Jeremy Sikorski noted that the technique was refined through testing on short films Paperman and Once Upon a Studio.
  • About 25% of the backgrounds in the upcoming short Lilo & Scratch consist of reused watercolor paintings from the original 2002 feature.
  • The studio intends to move away from the Pixar-popularized realism that has dominated its output for the last 15 years.

Decoder

  • Same-face syndrome: A common critique of 3D animation where characters share nearly identical facial structures and proportions, leading to a loss of unique character design.
  • Hybrid animation: A technique that combines 3D computer-generated geometry with 2D artistic treatments, textures, or hand-drawn elements to achieve a specific visual style.

Original Article

It's clear that some people are getting tired of the contemporary Disney style. That can be seen in the allegations of Disney same-face syndrome, the disappointment that Hexed doesn't look like its concept art and the perennial controversy over the hybrid live-action remakes, with Moana being the latest flop.

The fatigue was evident at D23 this year. The announcements that generated the most excitement were a return of 2D animation, if only in combination with live action for the nostalgia-heavy TV series in Oswald, and the news that Disney's Clay will look like claymation even if uses CG.

A lot of fans will be happy then to learn that Clay won't be a one off but rather the start of a whole new Disney era after Hexed. The studio's developed a new animation pipeline that will allow it to apply different art styles to 3D models, potentially replacing the realism popularised by Pixar with a unique look for each new movie – and it's all starting with Lilo & Scratch.

Set to show in cinemas alongside Hexed, Lilo & Scratch is the first theatrical short from Walt Disney Animation Studios in five years. Written and directed by Fawn Veerasunthorn and Malcon Pierce, it will see the much-loved blue alien Stitch having to contend with the introduction of a mischievous cat called Scratch. Maia Kealoha voices Lilo, reprising her role from the 2025 live-action film Lilo & Stitch, and Chris Sanders with voice Stitch again.

Like all of the studios' feature animations in the last 15 years, the short was made using computer-generated animation with 3D models, but these are blended with hand-drawn elements to create a hybrid style that looks surprisingly faithful to Lilo & Stitch from 2002.

Disney's VFX supervisor Jeremy Sikorski has said that the new pipeline was developed through experimentation on the previous shorts Paperman and Once Upon a Studio. Pixar is also exploring the same direction, as we saw in the Gatto trailer: environments, characters and sets are modeled and animated in 3D to retain spatial depth, lighting and camera movement, but certain characters and other details are hand drawn.

Disney says about 25% of the backgrounds in Lilo & Scratch are watercolour paintings reused from the original Lilo & Stitch, while more than a dozen new background paintings were created by artists including Tia Kratter and Larry Wu. Some of these were digitally painted in Photoshop to look like watercolour, while others were hand-painted on paper.

Combined with digital backgrounds and set extension, this blend of old and new hand-painted watercolours helped the filmmakers remain faithful to the look of the 2002 feature, Disney says.

In an interview at the Governors Awards in LA on Sunday, Disney Animation Chief Creative Officer Jared Bush confirmed that all original Disney movies from Clay onwards will use this approach. That doesn't mean that they'll all look like Renaissance-era 2D animation, but that each with have its own "wildly different" look.

Zootopia 3 and Frozen 3 will still look like we would expect, but Hexed may be "the last original in the Disney art style as people know it," he says.

Jared Bush shares updates on ‘Zootopia 3,’ ‘Frozen 3’ and ‘Hexed’ and reveals the new, upcoming animated films at Disney will have “wildly different art styles”: “We’re really going to be pushing into some new areas”

The new approach looks like a win for Disney. Despite some success with the live-action The Jungle Book and last year's Lilo & Stitch, the poor reception of Moana, Snow White and Mulan suggests waning interest in the remake formula is waning. Meanwhile, the 3D animation style that once looked so modern is starting to feel dated and generic.

Nostalgic audiences miss 2D animation, while younger audiences want something fresh. It sounds like Disney's new animation pipeline could make both things possible without sacrificing the efficiency that comes with 3D-based CG animation, which makes it much quicker and easier to swap and adjust environments, characters and props compared to traditional hand-drawn 2D, where even a relatively small change might mean having to redraw from scratch. The Disney principles of animation will remain in tact, but in a vast realm new possibilities.

I do wonder though. In ten years time, will people start to feel nostalgic about the much-maligned 3D Disney style?

Hexed will be released on 25 November. Lilo & Scratch will screen before it.

AI startup

Become a founding member of TLDR's AI community (2 minute form)

TLDR is recruiting a private community of AI builders to discuss industry news and technical launches.

Summary

What: TLDR is launching a curated forum for AI developers to discuss emerging research and product updates, with the best contributions featured in their AI newsletter.
Takeaway: Apply via the TLDR Typeform link if you want to join the group.

Original Article

TLDR is launching a curated community for AI builders to discuss major news and launches. The best links and comments will be featured in TLDR AI. Apply here to join.

AI enterprise

ResolveAI Introduces SRE-1, the Most Accurate Model for Production at Every Budget

ResolveAI has launched SRE-1, a model positioned as an accurate production-ready solution for site reliability engineering tasks.

Summary

What: ResolveAI's SRE-1 is marketed for high-accuracy production environments, intended to handle SRE-specific workflows across varying operational budgets.

Decoder

  • SRE: Site Reliability Engineering; the practice of using software engineering methods to manage infrastructure and service availability.

Original Article

SRE-1 offers unmatched accuracy for production across various budgets.

Data career

Are we Finally Entering the Golden Age of Data Science?

Automation is finally shifting the data science workload from infrastructure maintenance toward experimental design and high-level business questions.

Summary

What: Modern data tooling and AI agents are reducing the time spent on pipeline engineering and routine SQL tasks, freeing data scientists to focus on hypothesis testing and outcome analysis.
Why it matters: When infrastructure and basic data access become commoditized, the differentiator for data teams shifts toward statistical rigor and domain expertise.

Original Article

AI and modern data tools are making it faster to build pipelines and answer routine business questions. This gives data scientists more time to ask questions that matter, design experiments, and use AI agents to test what actually drives business outcomes.

Data aiagentsdevops

Airflow plays GTA2 (GitHub Repo)

This Apache Airflow 3.4 demo uses local AI models to navigate a character through Grand Theft Auto 2.

Summary

What: The project uses Airflow task loops to drive a GTA2 character through delivery missions, where each game move is an individual Airflow task. A 'bridge' using FastAPI and Playwright translates game state into text for an AI model to make steering decisions.
Why it matters: It serves as a creative demonstration of Airflow's ability to handle stateful, multi-turn AI agent orchestration rather than just linear data pipelines.

Decoder

  • Airflow DAG (Directed Acyclic Graph): A collection of tasks organized into a workflow with defined dependencies.
  • XCom: A mechanism in Airflow that allows tasks to exchange small amounts of data (cross-communication).

Original Article

This Apache Airflow 3.4 demo uses a local AI model to drive a car through a custom delivery mission in Grand Theft Auto 2. Each move is one iteration of an Airflow task loop, and a dashcam plugin lets you watch the run live or replay it later.

Data career

Data work is coding now

Natural language to code is eroding the barrier between domain expertise and software engineering, effectively turning data analysis into a coding-first activity.

Summary

What: Barry McCardel, CEO of Hex, argues that AI agents and code-generation tools are fundamentally changing data work. Analysts are moving from using GUI-based BI tools to writing and maintaining code via AI assistance, enabling them to build more complex, programmatic applications.
Why it matters: This trend suggests that the future of data teams is not in 'no-code' visual interfaces, but in 'code-first' workflows accelerated by LLMs, where the ability to interpret and refine code becomes more valuable than learning specific proprietary query languages.

Original Article

AI is making it easier for anyone to analyze data and build apps by generating the code for them.

Design

How .raw reworked STOW's identity to make its coffee roasting visible

Slovenian studio .raw redesigned the STOW coffee brand using scientific notation symbols and a rigid, technical design system to emphasize precision.

Summary

What: The new branding for specialty coffee roaster STOW uses a grey-scale palette with five accent colors, the Aeonik Mono typeface, and square brackets to mirror scientific laboratory labeling.

Decoder

  • Aeonik Mono: A technical, monospaced typeface that evokes the aesthetic of laboratory or industrial documentation.

Original Article

Slovenian branding studio .raw has redesigned specialty coffee company STOW's identity to communicate the scientific precision behind its sourcing, roasting, and testing processes. The system retains STOW's original factory-inspired symbol while introducing a geometric wordmark, Aeonik Mono typography, structured layouts, and square brackets borrowed from scientific notation. A restrained black, white, and gray palette is complemented by five accent colors representing different flavor profiles, making the brand's technical expertise and sensory qualities visible across packaging, menus, and other applications.

Design enterprise

How to experiment when designing in a regulated field like Healthcare UX

Designers in regulated fields like healthcare and finance must balance rapid AI-driven iteration with strict compliance, safety, and data privacy requirements.

Summary

What: This article explores strategies for UX designers to maintain experimental agility in high-stakes environments. It emphasizes that while AI tools allow for faster prototyping, the regulatory burden necessitates more rigorous validation and ethical safeguards compared to consumer-facing applications.
Why it matters: The democratization of design tools is creating a bifurcation in the industry: teams in unregulated sectors can move at 'AI speed,' while designers in critical sectors must build more robust, compliance-first workflows that prioritize trust and verification.

Original Article

Rapid experimentation is increasingly accessible through AI tools, but designers working in healthcare and finance face strict regulations around sensitive data, privacy, and product safety.

Digest devoured!

Nov 19

Home