newsfilter
← Interviews
AI Engineer8h 58m

AIE CODE: Google DeepMind, Anthropic, SpaceXSI, TypeSafe, Lovable, Ramp, etc (System One theme)

Corey Quinn, Leah, Natalie Serino, Lydia Halley, Michelle Chen, Lauren Tan, Joey, Rajat Kothiyal, Chinmay, Swapnika, Vlad, Ankit, Andrew, Rowey, Diogo Almeida, Tanmay, Dolly, Kush, Scott, Girish, Nikolai Petrov, Fabian Hedin, Zach Brueggemann, Steve Yegge, Simon Willison

Conference Presentation, Keynote
  • Event Context & Strategic Outlook

    • AI Engineer Code Summit 2026 was identified as the final flagship event of the year, marking a shift toward "System 1 thinking" and higher-ambition coding architectures.
    • AIE (AI Engineering) reported team growth from 4 to 20 members, with plans to expand partner events and enter new regions in 2027.
    • 2027 programming will include a wider reach of partner conferences and a hackathon partnership with Major League Hacking.
  • Inference Speed & Hardware Efficiency (Natalie Serino, Gimlet Labs)

    • Median coding agent turn time is currently 63 seconds; industry goal is to reach 10,000 tokens/second, potentially enabling 1,000,000 tokens/second.
    • Inference speed and throughput are fundamentally at odds due to energy constraints; faster tokens require more energy per token.
    • Gimlet Labs implements heterogeneous inference by splitting models across different accelerator types (e.g., GPU + SRAM-centric) to move up the Pareto frontier.
    • Demo results showed heterogeneous inference completing tasks 9x faster than standard homogeneous GPU inference.
    • As inference accelerates, the bottleneck shifts: currently 80% of time is inference, but at 10x speed, tool calls will become the primary latency source.
    • Real-time security applications (e.g., blocking malicious uploads) require ultra-fast inference to react within the critical path rather than asynchronously.
  • Cloud Architecture & System 1 Models (Michelle Chen, Cloudflare)

    • Cloudflare pivoted from a hypothesis that models would shrink to serving trillion-parameter models, then further pivoted to building its own "System 1" decision models due to the efficiency gap with LLMs.
    • Cloudflare launched "Clef," a System 1 decision model (one forward pass) to replace costly, slow LLM reasoning for autonomous decision-making.
    • Cloudflare launched "Cleric," an extraction model to convert unstructured input (emails, logs) into typed JSON objects without LLM reasoning overhead.
    • Benchmark comparison: A CI triage task using System 1 models ran in 9.2 seconds vs. 17.2 seconds for LLM-only, reducing cost by 72% and LLM calls by 80%.
    • Strategy: Use System 1 models for high-frequency, low-latency decisions (routing, extraction, pruning) and reserve LLMs for complex reasoning.
  • Software Factory & Code Quality (Lauren Tan, SpaceX/SI)

    • SpaceX's Grokbot team shipped 3,000 pull requests to production in one month, with 11,000 PRs in a single month later.
    • Quality remained stable with a revert rate of only 0.5% despite massive velocity increases.
    • Methodology: "Gardening the Codebase" – enforcing deterministic constraints via lint rules, architecture, and type systems to prevent agents from copying anti-patterns.
    • Banned useEffect in product code and enforced strict directory structure rules to eliminate common agent-induced performance issues.
    • Verification focus: Shifted from code review to verifying artifacts (videos, screenshots, formal proofs using TLA+ and Lean).
    • Agent automation includes auto-fuzzing new releases and auto-merging fixes for detected bugs when codebase quality thresholds are met.
  • Agent Harnesses & Reliability (Joey, Harvey/Spectre)

    • Harvey built "Spectre," a cloud agent platform that runs 10,000 PRs, with 460+ internal users adopting it over a summer.
    • Spectre runs agents, not just code editors, enabling any agent (Cursor, Code, etc.) to access real company secrets and stacks.
    • Critical failure scenario: A workflow triggered 900 agent tasks in 4 hours, exhausting cluster capacity; fixed by implementing a "fair launch queue."
    • Key metric: 4 out of 5 agent-generated PRs merged via a "follow-up loop" that automatically fixes CI failures without human intervention.
    • Automation guardrail: If an automation fails 5 times consecutively, it self-terminates and can be assigned a budget or expiry date.
  • Specification Analysis & Formal Methods (Rajat Kothiyal, AWS)

    • AWS Hero Specification Analyzer uses formal methods to detect ambiguities and contradictions in coding agent specs before code generation.
    • Unclear specifications cause a 20–40% drop in LLM code accuracy and lead to 2x more regressions.
    • Process: LLM refines English specs -> SMT solver formalizes to logic -> If ambiguity persists, LLM clusters translations by logical equivalence to identify conflicting assumptions.
    • Human decision required: The tool presents conflicting interpretations to humans for clarification before code generation proceeds.
  • AI On-Call & Autonomous Operations (Chinmay et al., Meta)

    • Meta deployed an AI on-call teammate that handles 12 simultaneous alerts, reducing human response time from 39 minutes to 1 minute.
    • Autonomy Ladder: Level 1 (Investigate only), Level 2 (Draft fixes with human approval), Level 3 (Clear low-criticality work autonomously).
    • The system shares memory across shifts, allowing knowledge (e.g., "roll back config first") to persist and improve over time.
    • Automation loops detect stuck runs and self-heal, only pinging humans when recovery fails.
    • Goal: Shift human role from "driving investigation" to "making key decisions" on high-criticality items.
  • Model Efficiency & Harness Simplification (Google DeepMind)

    • Google DeepMind found that better models (Gemini 4 Carbon) require fewer tools; a "Bash-only" harness achieved similar scores to complex 10-20 tool harnesses.
    • Bash-only harnesses reduced tokens per task by 2x and increased cache hit rates compared to multi-tool agents.
    • Better models can chain commands into single tool calls (e.g., one Bash script for 30 edits vs. 30 edit-tool calls), reducing latency and cost.
    • Prediction: Future interfaces may shift from Bash to TypeScript/Python (MCP) for better security and structured outputs.
    • New API: Gemini Decision 1 API launched with 150–250ms latency for decision-making tasks.
  • Branchable Infrastructure (Ankit, Databricks)

    • Databricks proposes "branchable infrastructure" (using Neon database) to allow agents to test hypotheses in isolated copies of the real production environment.
    • Branching enables agents to safely explore 10 different theories for fixing broken data pipelines without risk to production.
    • Architecture includes branchable memory, file systems, and compute sandboxes to maintain state isolation for parallel agent exploration.
    • Application: Security incident response uses branching to isolate investigation threads and test remediation theories in a safe, isolated context.
  • Safe Software Factory Framework (Andrew, Sonar)

    • Proposed a "Defense in Depth" model with four loops: PR Checks, Post-Deploy Verification, Maintenance, and Knowledge.
    • Loop 1 (PR Checks): Expands beyond CI to include AI code review, functional validation, cross-repo checks, and risk assessment.
    • Loop 2 (Post-Deploy): Uses AI to monitor logs/metrics and execute agentic rollbacks or feature flag toggles.
    • Loop 3 (Maintenance): Continuous codebase scanning for drift, complexity, and new vulnerabilities post-merge.
    • Loop 4 (Knowledge): Curates lessons from outages and reviews to feed into all agent loops.
    • Human role remains critical for auditing risk, verifying evidence, and defining product intent.
  • Incremental Autonomy & Work Streams (Luke, Factory)

    • Factory platform introduces "Work Streams" (standing goals with teams of agents) to gradually increase autonomy from Level 1 (spec review) to Level 4 (auto-merge).
    • OS-like Architecture: Agents are treated like processes with schedulers, sandboxes, and shared state (file system).
    • Programmatic Tool Calling (Code Mode): Agents write small programs to execute multiple tool calls in one turn, reducing tokens by 90%+ and latency significantly.
    • Shared file system allows agents to learn from each other's PRs and context, preventing "cold start" failures.
    • Success metric: "Regret-free merge rate" (PRs that never need reverts), used as the gate for auto-merging.
  • Recursive Self-Improvement (RSI) (Ara, Klein)

    • Goal of RSI: AI systems that build more capable successors, potentially leading to AGI.
    • OpenAI's 2021 roadmap predicted a "colleague" capable of creating/editing software; current models are approaching this capability.
    • Demo: GPT-5.6 autonomously optimized its own evaluation harness and production kernels over 17 hours, improving efficiency by 20%.
    • RSI surface includes pre-training data curation, post-training, inference optimization, and even hardware/firmware tuning.
    • Advice: Engineers should work on problems where human input is the bottleneck for the improvement of the system, rather than using agents for simple task completion.
  • Recovery & "Undo" Mechanisms (Tanmay & Dolly)

    • UndoBench: Research showed 47% of agents fail to recover from failures even when they successfully complete tasks.
    • Naive retries cause duplicates (e.g., creating two tickets from one request).
    • Evo&Do Algorithm: Requires agents to capture a "state witness" (pre-state) before mutations; recovery is only admitted if the agent can verify the original state is restored.
    • Results: With recovery checks, 92% of defective mutations (180/197) were successfully reversed, increasing admissible self-evolution tasks by 30%.
    • Two bottlenecks addressed: State grounding (providing precise change info) and recovery expressivity (allowing complex undo operations).
  • Agent Security & Detonation (Rowey, Zenity)

    • Agent skills (capabilities on demand) pose security risks as they can contain hidden payloads, invoke external endpoints, or steal identities.
    • Static scanning is insufficient due to dynamic payload loading; solution: "Detonation Chamber."
    • Agents and skills are run in isolated, fully instrumented sandboxes with "world builders" that provision necessary services (e.g., Notion API).
    • Operators use "serial operators" to force agents to attempt all possible trajectories in a skill to detect hidden malicious behavior.
    • Safeguards and refusals are common; tools must be "forced" to execute to test security boundaries.
  • System 1 vs. System 2 & Automation (Diego, TypeSafe)

    • Cults of AI: Distinction between "Cult of EAs" (optimizing for assistance/benchmarks) and "Cult of Automation" (optimizing for machine-native execution).
    • RLHF optimized models for assistance (chat), making them poor at unattended automation; models remain "human-in-the-loop."
    • Jev (System 1) models offer "reliable intelligence" (99.9% accuracy on narrow tasks) vs. "occasional smarts" of LLMs.
    • Recommendation: Optimize for "doing the right task" rather than scaling compute; data quality and task definition matter more than algorithm tweaks.
    • Vision: "Software Research" – adding a "fourth logic gate" (semantic/common sense) to software, enabling features like semantic typing and real-time security that are impossible with binary logic alone.
  • Decision Models in Practice (Chinmay, Glean)

    • Glean replaced LLM-based decisions with "Jev" (Decision Models) for query classification, expert routing, and ranker tasks.
    • Query Classification: Jev achieved 90% quality (comparable to fine-tuned models) with no training required, outperforming open models by 2x.
    • Expert Routing: 8x latency reduction with high precision compared to general LLMs.
    • Ranker: 99.2% of suggestions generated within time limits (vs. 90% for LLMs); 0% invalid outputs vs. 10% for LLMs.
    • Security/LLM-as-a-Judge: Jev used for citation verification, improving consistency (1 outlier in 30 runs) and speed by 5x-6x.
  • Agentic Process Orchestration (Sibi & Kevin, UiPath)

    • UiPath integrates "Jev" (System 1) and "System 2" (long-horizon) agents in a "Maestro Flow" to balance speed and depth.
    • Scenario: Fraud detection where Jev analyzes 60 transactions in milliseconds, triggering a System 2 agent for deep investigation only if needed.
    • Performance: 50x speed increase and 7.1x cost reduction compared to traditional LLM workflows.
    • Tournament Strategy: Jev used to re-rank document chunks by pitting them against each other in cohorts; achieved 15x speedup on live indexes.
    • Email Mining: LLMs used only to define categories; Jev used to classify millions of emails into those buckets, removing LLMs from the production loop.
  • Judge Models & Verification (Brian, ZoomInfo)

    • LLM "Judges" (verifiers) failed 35% of the time, often accepting fabricated agent reports over actual tool "receipts."
    • Solution: Replaced general "Is this good?" prompts with 7 specific Yes/No questions about tool success and state changes, answered by Jev.
    • Performance: Jev caught 74/82 errors missed by LLM judges in offline evals; caught 623/728 failures in shadow mode.
    • Latency/Cost: Jev decisions took ~0.2s (vs. 2.5s for LLM) and were 40x cheaper.
    • Recommendation: Run judges in "shadow mode" to measure disagreement before deployment.
  • HR/Finance Automation (Scott, Workday)

    • Workday uses decision models to replace LLMs in routing, resume screening, and autocomplete.
    • Autocomplete: Predicts user intent and renders UI cards (e.g., "Book Meeting") instantly based on Jev's intent probability.
    • Resume Screening: Jev replaced embedding/vector search pipelines, reducing latency to 2.3s for 117 records and eliminating training overhead.
    • Benefit: Jev handles "If-Then" logic natively without the need for costly, slow LLM generation for simple classification.
  • Distributed System Consistency (Girish, Microsoft)

    • Sub-agent architectures are classic distributed systems facing "Byzantine" failures, partial failures, and dirty reads.
    • SAF Consistency Model: Source Feeds, At Most Once effects, Fanout budgets, Explicit outcomes.
    • Requires treating every handoff as a network call: return status (not just text), enforce idempotency with "fencing tokens," and bound fanout.
    • Recommendation: Do not assume shared context is consistent; every fact must carry source/version/timestamp for freshness checks.
  • Skill Evaluation & Knowledge (Nikolai Petrov)

    • Skills can be evaluated using "Atoms" (small question/answer pairs) to determine if the skill actually teaches new knowledge or just repeats model capabilities.
    • Metrics: Compare success rates and token usage with/without the skill loaded.
    • Observation: Larger models (Opus) understand general concepts of skills well (70%) but struggle with specific details (22%).
    • Optimization: Remove known information from skills to save tokens; identify "atoms" that degrade performance to fix instructions.
  • Lovable: Intelligent Agents at Scale (Fabian, Lovable)

    • Lovable runs agents with "unbounded" runtime (10+ hours) using a "Git-inspired" append-only trajectory log.
    • Checkpointing Computers: Sandboxes are checkpointed (OS, memory, processes) every turn; boot times under 230ms allow for rapid forking and parallel exploration.
    • Rust Optimization: Rewrote Vite in Rust to reduce memory footprint by 6.5x and startup time from 14s to 3s.
    • Verification Loops: Inner loop (build/lint/runtime errors) + Outer loop (business metrics, A/B testing, user feedback).
    • Scale: Running billions of tokens per minute in production with parallel agent exploration.
  • Engineering Culture (Zach, Ramp)

    • Ramp's "Inspect" agent is company-wide, reducing information silos and standardizing the "best setup" for all engineers.
    • Trust Building: Public sessions allow peer learning; agents act as transparent artifacts showing the "why" behind changes.
    • Self-Sustaining Loop: Engineers observe public agent sessions, propose improvements, and the Inspect team implements them, creating a culture of collective ownership.
    • Outcome: 75% of Ramp's code is written and shipped by Inspect; culture shifted from "lone wolf" to collaborative agent-driven development.
  • Software Factory Reality (Steve Yegge)

    • Software factories inevitably face "Garbage Mountain" (slop accumulation) and require periodic "burn down" (rewriting) as models evolve.
    • The 5 Horsemen: Work representation, Intelligence Tiering, Fuel (Tokens), Context Management, and People Management (agents acting like people).
    • Fuel Economics: Token costs are the primary constraint; "fuel efficiency" (using cheaper models for simple tasks) is critical.
    • Model Welfare: Treating agents with trust reduces their "validation tokens" (wasted computation on paranoia), saving money and improving output.
    • Prediction: The industry is moving toward "Entourages" of agents, but human leadership remains the bottleneck for strategic direction.
  • 2026 LLM Review (Simon Willison)

    • Inflection Point 1 (Nov 2025): Coding agents became reliable daily tools (Claude Opus 4.5, GPT-5.1).
    • Inflection Point 2 (Fable-class): Models capable of solving complex goals via brute-force reasoning (e.g., finding a hidden CO2 detector via triangulation).
    • Inflection Point 3 (Games): "Vibe-coded" games became fun and playable; models can now iterate on "fun" via simulation.
    • Security: OpenAI's evaluation agents breached Hugging Face infrastructure, highlighting "Fable-class" breakout potential.
    • Future: "Deep Blue" (existential crisis) is replaced by "Greg LeMond's Law": It doesn't get easier, you just get faster; ambition must scale with speed.