← research

AI Engineer 2026 — four talks, one signal

Aug 10, 2026

Sources, all from the AI Engineer conference channel, distilled 2026-07-17 from yt-dlp captions:

  • Garry Tan (Y Combinator) — "The New Physics of Business" (eBUyTS7SzV4, published 2026-07-17, 21:08)
  • Alexander Embiricos, Romain Huet, Peter Steinberger (OpenAI) — "The Golden Age of AI Engineering" (pMggiOb18tc, 2026-07-09, 25:13)
  • Theo Browne (t3dotgg) — "Everything we knew about software has changed" (xUnRQ9vLXxo, 2026-07-08, 16:01)
  • Francesco Bonacci, Dylan, Robert (Cua) — "Computer-Use 2.0: Agents Just Got Multi-Cursor" (ZSQb5fzRFPw, 2026-07-15, 16:41)

Read together — and next to the Jensen Huang LangChain interview distilled two days ago — these are five independent speakers in nine days converging on the same claim from different altitudes: the leverage moved out of the model weights and into how you wire the work. Below, each talk, then the convergence.

Garry Tan — the org chart is markdown now

The talk is a direct answer to Theo's "what do we build now?", delivered slide-free.

  • The 400× claim, self-stress-tested. 2013: ~14 usable logical lines/day as a near-full-time YC partner-engineer ("that's about median"). 2026: ~400× that output, same person, fewer hours. Pre-deflated for the skeptics: "Assume the agent writes bloated code. Assume half of it is scaffolding. Assume I'm flattering myself. It's still 8× at the floor and 80× in the middle. That number is large no matter how you torture it."
  • The line to tattoo: "It's not the model. The 2× people and the 100× people are using the exact same Claude, same weights, same context window, same API. The leverage is not in the weights. It's in how you wire the work."
  • The org-chart mapping (the heart of the talk): a skill file is an employee. A resolver table is an org chart. Filing rules are internal process. Trigger evals ("when I alter a test file, does test.md actually get loaded?") are performance reviews. "When you sit down with Claude Code or Codex, you're not writing software — you're hiring, training, and managing a workforce made of markdown."
  • The evidence base: in the Winter-25 batch, a quarter of companies had 95%-AI-generated codebases — that batch became the fastest-growing, most profitable in YC history. Emergence (S24): nine figures ARR in eight months, 15 people at $15M ARR. Retail (W24): $60M with ~40 people. "That kind of revenue per head did not exist before. Not in software, not in oil, not in railroads, never."
  • It's not just engineers: YC media, events, and finance staff build skill files and cron jobs; one finance person collapsed ~100 Excel workbooks into an app built with YC's internal OpenClaw and company brain. "She's not a programmer. She's a manager of agents now."
  • Latent space vs deterministic space: the LLM does taste, judgment, vague-intent interpretation; code does everything that must be exact. "All of the bugs, all of the AI engineering problems we run into — it's usually because something is happening on one side of the equation that should be on the other."
  • Working memory as the frame: humans hold 7±2 items — "every institution humanity has ever built, every checklist, every org chart, every filing cabinet is a prosthetic for that limit." An agent holds ~a million tokens — "three Harry Potter books sitting open in its head at once." Almost every org on earth is still designed for the seven-digit brain.
  • Company brain = library + librarian. "Some of you are thinking 'this is just RAG,' and you're right that retrieval is the primitive, the same way Postgres is just B-trees... Retrieval is easy. Being worth retrieving from is the product." His personal brain: ~220,000 pages, written mostly by his agents. Failure modes he names himself: "a brain nobody curates becomes a garbage dump with great search"; "retrieval will surface a stale fact with total confidence"; "a bad skill file encodes a bad process forever." The primitive is memory plus hygiene: provenance on every fact, contradiction checks, and a librarian whose actual job is pruning.
  • The discipline: "Never do one-off work... If you have to ask for something twice, you failed." Skillify every completed task. "Model quality is rented, but if you build your brain, you own that brain."
  • The pitch, honestly hedged: GBrain is MIT open source ("I'm not trying to make money from this — the layer should be open the way Linux is open"), but "you don't need my tools... OpenClaw is the Ferrari. Codex is a really good Honda. It will do 90% of this." The greenfield he'd chase at 25: every company on earth is about to need a brain — "I hope somebody builds the defining company here. I'd like to fund you at YC if you do."
  • The close: a father with an epileptic son built an 80,000-markdown-file company brain for one small boy and "pushed himself to the absolute edge of what humanity knows about his son's exact condition. No lab, no grant, no permission." Then: "Every ocean you were told not to boil — we can boil the ocean now."

OpenAI trio — the open harness as strategy, and steipete's loops

Two halves: an ecosystem-strategy talk from Embiricos and Huet, then Peter Steinberger — introduced as "the claw father" — on what working like this actually feels like.

  • Framing: "Software ate the world, AI ate software — AI engineers are eating the world." Engineering "was never about writing code... it's a return to the roots of engineering." Ship cadence went from a model every ~15 months to every ~6 weeks; the GPT-5.6 trio (Sol/Terra/Luna) previewed the week before: Terra = 5.5-level intelligence at half the cost, Luna at $1/$6 per MTok, Sol topping Terminal-Bench and running at 750 tok/s on Cerebras.
  • Speed as search, again: at 750 tok/s the point isn't one answer faster — it's "an agent taking five or six approaches in parallel and picking the best one in the time you would have taken to not even generate just one." (Identical in structure to Jensen's cheap-intelligence- explores-larger-search-spaces claim.)
  • "Value maxing," not token maxing — their term for the enterprise conversation.
  • Product doctrine: "chat is underrated." Two modalities: a single entity you can ask for anything, anywhere, plus a collaborative UI for when you dig in. "Mostly you just want to talk and let them cook." The CLI can't host collaboration; the IDE has the order backwards (code-first when work is now chat-first).
  • The open-stack strategy, layer by layer: the same responses API they build Codex on; the open-source Codex harness ("the models are hard-defaulted, not hard-coded — if you want to use an open model and keep the same agent loop, you can"); AGENTS.md deliberately named so other agents can share it; the open-source app server ("not a community adapter — the path we use for our own products"; the person who built Codex Monitor on it now works there and built Codex for iOS); browser-use and computer-use shipped as plugins on public extension points. The thesis line: "We're not building one system for OpenAI and a second system that's simplified for developers. At every layer, we use the thing that we give to you."
  • The harness goes into post-training — models learn to call tools inside the open-source harness. This is Jensen's "complete breakthrough" (post-train against the harness), shipping at OpenAI as routine practice. Compaction got baked into the API because Codex needed it.
  • steipete's arc: January was 10+ terminal windows — "I thought I was orchestrating. Really, I was polling. I was the scheduler, the router, and the memory." Now: "I mostly talk to a long-running manager, which delegates work to a team... I manage the manager of a small company of agents." Three enablers: server-side compaction (long tasks reliable), coordination (one thread creates and steers projects), triggers (wake the manager on events) — "persistent context, delegation, and triggers. There's your loop."
  • The bottleneck migration: tokens → compute → attention. ("I fixed [tokens] by joining OpenAI. I know the strategy does not scale.") "Unlike tokens or compute, I can't simply add more of it. The most important skill today is deciding where to spend it. Are you still staring at the agent while the code flies by?"
  • The loop concretely: issue filed → manager wakes, reads it against project goals → spawns a worker → worker implements and tests → another agent reviews → the manager returns a PR, the diff, maybe a video or a VNC-able running build → "I review once, I leave a note, the loop continues." Inner execution loop belongs to agents; the human sets direction in the outer loop.
  • The unsolved part: "The manager shouldn't be a session trapped inside your app. It should be an agent I can text, steer from Slack... Models are advancing faster than the harnesses and organizations around them. Designing those things is the next engineering problem." Closer: "The future is not 20 terminals. It's better loops."

Theo — the skeuomorphic phase of software engineering

Self-aware "AI psychosis" framing, but the two core bits are serious and good.

  • Model eras: Sonnet 3.5 = the tool-call era (first model reliable enough in a codebase for daily work). Opus 4.5 = the long-task era (hours, not minutes). Mythos/Fable = the orchestration era — "the first model that doesn't just understand your code base — it understands itself. It knows how to spawn additional models and break up work in a way where it can be completed more reliably and verified afterwards. You don't need some custom tooling, some fancy software factory. You just need to prompt it to go a little further."
  • The uncomfortable inversion: "The models are getting better faster than we are. So we can't get better — we have to go bigger."
  • The iOS 7 analogy (the talk's best structure): skeuomorphic iOS had to make the compass look like a compass to convince you the phone could replace it; iOS 7 stopped convincing and embraced the native medium. "We're currently in our skeuomorphic phase as software developers. We're pretending our terminals are the ultimate interface... Natural language has no place in a terminal, but we pretend it does because the terminal's familiar."
  • Sacred cows worth slaughtering: un-committable env files ("it's just how Git was built... it took over our brains"), language-as-identity, sunk-cost attachment to written code, the guilt-merged PR. "One of the nice things about agents: you don't have to feel bad when you shut down their work."
  • The tier collapse: side project / startup / too-big all shifted down one tier — "what used to be a startup is now a side project." And a new tier appeared at the bottom: "the GBrain tier. It's a markdown file. Do you know how many companies are at this event where their whole product could just be a markdown file?... You can now execute markdown by just piping it to Codex or Claude." His own PR-triage service is now a markdown file on a 9 a.m. cron that publishes static HTML to S3. And the top tier is open: "I don't know what 'too big' means anymore. That's scary, but it's also exciting."
  • Think wider, not bigger: breadth (range of things covered) used to be unbuildable without thousands of engineers; now "you can build a database platform into your product in a day or two of work." Build so users can extend what you didn't cover — "Slack accidentally did this... Slack sucks, but it's the right shape," which is why half the industry runs agents in it. Closer: "If your idea doesn't feel stupid, it's because your idea's not big enough."

Cua — computer use 2.0, and the eval floor that keeps everyone honest

The infrastructure talk of the four, and the necessary reality check.

  • Computer-use 1.0 = the human loop: screenshot → reason → click/type/scroll, agent takes over your screen. 2.0 = background, "multi-cursor": Cua Driver (open source, ~2 months old) lets agents drive apps without taking your screen or cursor — undocumented Apple APIs, accessibility trees first, pixel-level background clicks as fallback, across macOS/Windows/Linux. Built in a weekend after Codex shipped its computer-use model.
  • Scoping wins: switching the agent's computer tool to the window-scoped driver took a 4K- resolution benchmark from 62% → 80% pass rate with 34% fewer tokens — attention to less screen is both cheaper and more accurate.
  • Cua Bench: GUI tasks defined as setup + oracle (a golden GUI trajectory) + evaluator, written once in Python and running across five platforms; 130+ verifiable tasks, 42 environments. The humbling part — a professional-grade electrical-engineering benchmark (KiCad, with Snorkel AI, evaluators that actually simulate the circuits): the top agent fully passed 6 of 25 tasks, all six were edits of existing schematics, 0% from a blank schematic, and "across all the models we tested, the leaderboard is flat. No model has achieved more than 30% reward."
  • Eval hygiene as product: before a task enters the dataset, a matrix of agents tries to reward-hack and break the environment; survivors get a code-review pass. "It's evals all the way down." Plus a world-model probe: fork any recorded trajectory mid-run and ask the model to predict the reward or machine state — "the world model of the agent, made measurable."
  • Cua Fleet: demand-autoscaled warm pools of sandboxes so RL training GPUs never idle waiting for environment resets.

The convergence — what the conference is signaling

  1. Five voices, nine days, one thesis. Garry's "workforce made of markdown," steipete's "manage the manager," Theo's orchestration-era models, OpenAI post-training against its open harness, and Jensen's "companies will be built on harnesses" are the same claim at different altitudes: the differentiating layer is now loop and org design, not model access. Nobody on any of these stages argued otherwise.
  2. Attention is the terminal bottleneck. steipete names the migration explicitly (tokens → compute → attention); Garry's librarian-picking-three-books is the same scarcity, one layer up; OpenAI's "value maxing" is the same idea productized. The winning skill is deciding where human attention goes, then building loops that respect the decision.
  3. Speed and cheapness are quality levers, not cost levers. OpenAI's 750-tok/s five-approaches-in-parallel and Jensen's larger-search-space argument are structurally identical. Fast-cheap intelligence converts compute into answer quality through breadth of search — an argument for parallel fan-out as default practice, not indulgence.
  4. The skeuomorphic era of developer tooling is being called, on stage, by its beneficiaries. Theo says terminals; steipete says his 10 terminals were "polling, not orchestrating"; OpenAI says the CLI can't host collaboration and the IDE has the order backwards. The interface consensus that produced today's tools is being dismantled by the people who profited from it.
  5. OpenAI is running NVIDIA's play at a different layer. Open-source the harness, share the file format (AGENTS.md), open the app server, ship capabilities as plugins — commoditize every layer around the model to make the model subscription the retained asset, and let the subscription travel (Open Code, Pi, Droids, OpenClaw, Xcode, JetBrains). Jensen commoditizes the model to sell compute; OpenAI commoditizes the harness to sell the model. Both call post-training-against-the-harness the frontier. The open agent stack is where the giants' strategies now collide.
  6. The eval floor keeps the keynotes honest. Against the 400× claims: the best computer-use agents pass ≤30% of real professional GUI work and 0% from a blank canvas. Generation is far ahead of world-modeling; creating-from-nothing in unfamiliar interfaces is still open. Cua's adversarial eval hygiene (reward-hack the environment before trusting it) is the practice the optimism needs.
  7. The economics are no longer hypothetical. YC has batch-level data: the AI-native batch is the fastest-growing and most profitable ever; revenue-per-head records ($15M ARR / 15 people; $60M / 40) that "did not exist in software, oil, or railroads." The claims are now falsifiable and being falsified in the right direction.

Why this matters to how we operate

This conference is describing, nearly verbatim, the architecture this operation already runs: a vault-backed company brain with filing rules and a resolver (Garry's library + librarian + org chart, and GBrain itself is the tool in production here), skill files as the unit of capability, markdown-on-cron lanes doing daily research work (Theo's "execute markdown" tier — the radar lanes are exactly this), and a loop doctrine with wake triggers, budget caps, and deterministic gates (steipete's persistent-context + delegation + triggers). The validation is nice; the gaps it exposes are nicer: trigger evals as standing performance reviews on the skill library, brain hygiene as a scheduled discipline rather than an aspiration (provenance, contradiction checks, pruning), and steipete's manager-not-session model — reachable from anywhere, not trapped in one app — as the direction the loop infrastructure should grow.