Economic value in AI is concentrating in chips ($300B+ revenue), not applications—Nvidia's data center business earns ~75% gross margins while app-layer profitability ranges 0-30%.
AI triangle resembles 2004 cloud economics; it took AWS eight years (2004-2012) to flip from infrastructure to applications dominance—this AI inversion may take longer due to substrate complexity.
Chip inference workloads represent ~40% of Nvidia GPU fleet utilization, training ~60%; inference share expected to grow as applications scale, unlocking profitability.
ChatGPT reached ~1 billion users monetized at $10/user/year; comparison: Alphabet monetizes 4 billion users at $100/user/year—growth requires expanding beyond knowledge work into mandatory daily utility status.
Hyperscaler ASICs (Google TPU, Meta MTIA, Amazon, OpenAI efforts) represent the likeliest repricing catalyst for the semis layer; breakthrough success would reshape dominance.
Vertical integration winners: Google (internet), Apple (mobile), Meta (social), but cloud remains heterogeneous—full vertical integration may be necessary for AI super-cycle dominance.
Revenue concentration risk: last two years added $350B to AI ecosystem; 75% accrued to semis, 90% of applications revenue split between two companies (OpenAI, Anthropic/Google).
AI application monetization will likely shift from subscriptions ($10/user) to intent-based advertising with better attribution and pricing than mobile ads—no model yet proven on phone-scale consumer AI.
Apps layer infrastructure quality poses bottleneck: hardest part of AI ecosystem is getting the substrate right—until solved, profitability remains trapped in chips.
Feature versus platform distinction critical for infrastructure startups: companies solving narrow problems risk becoming AWS features rather than standalone businesses.
Maps the generative AI value chain across semiconductors, infrastructure, and applications, showing $350B in new revenue concentrated at Nvidia despite 10x application growth over two years. Covers why near-zero marginal cost breaks down when serving users burns GPU compute, and what conditions—custom ASICs, inference dominance, hyperscaler integration—could reprice the stack.
Language models generalize better from in-context information than from fine-tuned parameters—reversals and syllogisms hit 99% accuracy in context but near chance after fine-tuning.
The reversal curse persists even when training models from scratch on synthetic data, showing it's a fundamental limitation of parametric learning, not just fine-tuning.
In-context learning succeeds because structural patterns (reversals, logical implications) appear frequently in natural training data, making them learnable as flexible procedures.
Parametric learning ties knowledge to explicit surface forms in training data, while in-context learning preserves richer detail that enables flexible reuse.
Offline data augmentation—using the model's in-context reasoning to generate latent inferences and adding them to training data—matches or exceeds pure in-context performance.
Test-time episodic retrieval (bringing learned documents back into context via oracle memory) restores generalization on reversal and other latent-structure tasks.
Reinforcement learning can train models to regenerate needed information via chain-of-thought, generalizing reasoning patterns to new domains, though it struggles with symmetry-breaking tasks like reversals.
These three methods trade off compute cost: offline augmentation is expensive to train but cheap at test time; test-time retrieval is cheap to train but expensive at inference.
Hippocampus-like episodic memory and cortex-like parametric learning are complementary in humans—fast episodic storage plus slow parametric integration prevents interference while enabling rapid single-trial learning.
Parametric systems need statistical structure to efficiently constrain inference; pure symbolic reasoning lacks feasibility for real-world generalization, requiring the models learn content-sensitive reasoning patterns.
Controlled experiments on facts, syllogisms, and encodings show fine-tuned models fail to reverse relations or compose logical chains, while the same models nearly ace both tasks given the data in context. Three mitigations tested: offline data augmentation, episodic retrieval at inference time, and RL-driven regeneration, each trading training cost for inference cost.
CSS contain and content-visibility eliminate layout thrashing without JavaScript—contain shields containers so layout changes don't trigger recalculation of the entire page.
content-visibility: auto is native virtual scrolling: browser completely removes off-screen elements from style recalculation, layout, and paint processing.
Contain layout has a design downside—it affects z-index and stacking context, causing overlapping elements to break; content-visibility avoids this issue.
Contain paint reduces paint surface by cutting off overflow content; content-visibility requires explicit height dimensions but delivers massive performance gains.
Measured with DevTools: zoom 0.1% in and out while recording to isolate layout and paint work; deeply nested boxes with margin animations show layout thrashing clearly.
Adding content-visibility: auto and fixed heights to images, SVGs, and tiles reduced layout tasks from severe spikes to nearly zero with minimal CSS changes.
Content-visibility supported everywhere except IE; contain paint/layout supported cross-browser since Safari shipped it recently.
Real-world demo: infinite-scroll website went from constant red recalculate-style spikes to clean profile by applying content-visibility auto and contain layout to tiles.
Contain strict combines layout, paint, and size but is annoying to use; content visibility easier to apply and equally performant without design side effects.
Off-screen paint of images (e.g., in infinite scroll) completely disappears when content-visibility applied—no paint work triggered for invisible content beyond viewport.
Michael Hladky measures layout and paint costs in Chrome DevTools, then shows how `contain: layout` blocks relayout cascades, `contain: paint` shrinks paint surface, and `content-visibility: auto` removes off-screen elements from the render pipeline entirely — cutting layout and paint spikes to near-zero on an infinite-scroll page with one CSS rule per tile.
AWS believes defect rate improvements, not frontier model advances, will unlock enterprise agentic AI adoption and value creation.
Low-frequency, low-consequence defects represent the key opportunity; high-consequence defects require expert-only fixes and severely limit scale.
Hydro (Rust framework) enables agents to build correct-by-construction distributed systems, addressing models' weakness in concurrency and failure reasoning.
Cedar policy language uses formal reasoning to make authorization correct-by-construction, reducing defects in critical control systems.
Auto-formalization converts natural language specifications into mathematically precise Cedar or Lean code through interactive conversation with customers.
Deterministic agent steering via pre- and post-conditions on tool calls balances model creativity with mathematically precise behavioral constraints.
Benchmarks should measure failure severity and customer impact, not just failure density; replace metrics like pass@10.
Industry needs end-to-end evaluation including operational properties—performance, cost, durability, availability—not just raw model capability.
AWS open-sourced Trusted Remote Execution, constraining agent-built cloud operation scripts with formal Cedar policies in production.
Investing in failure understanding and mitigation is as important as improving best-case performance; culture must treat worst days seriously.
Marc Brooker maps agent failures into four quadrants by frequency and severity, argues only low-frequency, low-consequence errors have real enterprise TAM, and outlines AWS investments in correct-by-construction frameworks (Hydro, Cedar), automated reasoning, and deterministic agent steering to get there.
UK government created 'insurgent unit' at Number 10 with high political backing, market-rate pay, and autonomous hiring to deploy AI engineers across departments—bypassing traditional civil service constraints.
0.7-0.8% selection rate for fellows using custom technical hiring process; exclusively recruit outsiders from labs, big tech, and research institutes to prevent institutional lock-in.
7.25 million NHS waiting lists, 350,000 court case backlog, only 20% of planning applications decided on time; AI could deliver £40 billion annual productivity gains across UK government.
First forward-deployed engineers embedded in Number 10 policy teams—observing workflows, co-designing solutions, moving from idea to implementation in weeks instead of months.
Extract tool, built with DeepMind on Gemini, digitizes planning applications including handwritten and hand-drawn maps; rolling out to every local authority to address planning delays affecting economic growth.
Cabinet Office avoided £1.5 million lawyer contract by embedding one engineer for two weeks to automate UK statute book analysis—plus created reusable, updatable tool.
Just AI spin-out deploys fellows into prisons and criminal justice system as forward-deployed engineers working with parole officers to reduce drug smuggling and improve operational efficiency.
Policy simulation tool lets decision-makers test impact of policy choices (e.g., universal credit changes on household finances) before implementation at faster pace than traditional analysis.
Recruitment pitch explicitly seeks 'missionaries not mercenaries'—ambitious technologists from Y Combinator, academia, and industry willing to take pay cuts for high-impact public service work.
Scaling strategy focuses on making insurgent model become 'business as usual' and developing horizontal solutions (transcription, call center automation) applicable across 400,000-person civil service.
Britain's No. 10 Data Science Team runs a market-rate fellowship recruiting from labs, big tech, and YC founders—never career civil servants—and embeds them directly in departments. Early deployments include an Extract platform built with DeepMind to automate planning applications, with spin-offs now placing engineers inside prisons and scaling across 400K public-sector workers.
Generator-evaluator pattern (inspired by GANs) splits agent responsibilities into separate context windows: one builds, one critiques using Playwright/browser automation, creating adversarial pressure that improves quality.
Claude Opus 4.6 can run continuously for 12+ hours with single-session compaction instead of resetting context, eliminating need for fresh sessions between tasks.
Models are bad self-evaluators due to sycophancy; a separate harsh critic LLM is more tractable to tune than making builders self-critical.
Planner-generator-evaluator loop with contractual handoffs works better than single agents: planner sets high-level direction, generator and evaluator negotiate testable acceptance criteria before building.
Grading subjective quality (design taste, originality) is possible with detailed rubrics and few-shot examples; Anthropic weights design/originality heavily to prevent AI-slop aesthetics.
Multi-hour full-stack apps (6 hours, ~$200) now achievable with generator-evaluator harness; same prompt in solo loop produces non-functional features (e.g., games with unresponsive controls).
Context rot and context length anxiety (model rushing near window end) were critical problems in earlier models; Opus 4.6 handles coherence much better, reducing need for architectural workarounds.
Read traces by hand, not just evals: identify where model judgment diverges from yours, then tune prompts. Automated trace analysis is a secondary pass; human reading is primary debugging loop.
Harnesses co-evolve with models: as frontier improves, simplify harness (drop sprint decomposition, reduce evaluator cadence), then test to verify. Strip out scaffolding only after confirming models handle it.
File system state (not context windows) for long-running agents: use JSON files for learnings, timestamped logs, git commits; lets future models or humans pick up work without re-inventing history.
Ash Prabaker and Andrew Wilson detail three failure modes for long-horizon agents—context limits, poor planning, and self-evaluation bias—and show how a GAN-inspired generator-evaluator pattern with Playwright-driven rubric testing enables 5-6+ hour runs. Concrete example: a retro game maker that solo single-session runs failed to complete.
