Where is all the automation?

Diogo Almeida, TypeSafe AI23:20 · Nov 2026 · 53K views
Thumbnail for Where is all the automation? Watch on YouTube
TL;DR
  1. 1

    LLMs are optimized for helping people, so they are unusually good at assistance and unreliable when left to do cognitive work on their own.

  2. 2

    Reliable machine-native AI requires choosing a training task that rewards dependable behavior, rather than judging models mainly by benchmark scores.

  3. 3

    Software engineers should build around decomposition, verification, explicit state, semantic types, and new software primitives that make more automation possible.

Summary

Diogo Almeida argues that current AI is stuck between impressive demonstrations and limited automation because language models were trained for human assistance. RLHF puts the human into the loop, which makes models good at producing useful answers but poorly suited to background work that must run reliably. He describes this gap as getting Einstein 95% of the time and Mr. Bean 5% of the time. Almeida presents Jev as an attempt to optimize for narrow, dependable intelligence instead. He then turns to software. Coding agents make software cheaper to write, but they have not changed what software can do. He asks engineers to put intelligence inside the software's decision-making loop and treat it as a new semantic primitive, like adding a fourth logic gate. His proposals include verified decomposition, explicit state management, shared agent memory, semantic types, real-time security, and playful experiments that explore what software can automate.

Key ideas
01:34

AI is jagged because benchmark ability and automation ability are different

Almeida describes two reactions to AI. One group points to models exceeding human performance on many benchmarks, while everyday software and business activity remain largely unchanged. The other group sees that models can solve extremely difficult mathematics yet fail at tasks that appear simpler, such as automating a drive-through or touching accounting. His explanation is that these are different kinds of work. Deep research is an assistance task where a human still decides whether the result is correct. Automation needs the system to make the decision and carry out the work without that human judgment. Code is the language of automation, so models need to integrate with code rather than only produce helpful prose.

03:31

RLHF optimized language models for assistance instead of autonomous work

Almeida says reinforcement learning from human feedback is part of the reason current AI remains human-dependent. The human feedback is built directly into the optimization target. In his view, essentially all current language models are optimized for assistance. They are excellent at answering a person's queries, but people should not trust them with cognitive work that runs in the background unless the task is trivial to verify. Even systems trained with reinforcement learning from verifiable rewards can be difficult to use without human-oriented training. His proposed alternative is machine-native AI, designed around the behavior required for automation.

05:53

Choosing the right task can matter more than scaling the model

Almeida says the field often focuses on algorithms and compute while overlooking the task being optimized. He calls selecting the right task the bitterest lesson. Next-token prediction made pretrained models good at generating strings, while masked language modeling would not have produced the same result simply by adding more compute. He makes a similar argument about RLHF: the training data and objective created a large improvement in instruction following even with relatively simple algorithms and a GPT-2-sized model. For Jev, the claimed leap came from optimizing for a different task. The model should be trained for dependable machine work, not only for pleasing a human reader.

09:35

Automation needs narrow reliability because occasional brilliance is unusable

Almeida describes unreliable language models as being Einstein 95% of the time and Mr. Bean 5% of the time. The problem is that users cannot reliably identify which behavior they are getting before trusting the result. He argues for extreme, narrow reliability instead of occasional impressive intelligence that must be checked after the fact. This quality does not necessarily appear on standard benchmarks. He attributes Jev's appeal to the fact that it delivers dependable behavior, rather than to speed, cost, or interface. A model that does what it is expected to do can be more useful for developers than one that produces occasional spectacular answers.

10:56

Software should put intelligence inside its decision loop

Almeida says AI has made software cheaper to write without changing software itself very much. A chatbot sitting beside an application cannot make expensive decisions inside that application. He wants engineers to move beyond coding agents and put intelligence into the inner loop of software. His blue LED analogy describes how adding one new primitive can create uses that are much larger than the primitive's apparent incremental capability. He compares machine-native intelligence to a fourth semantic logic gate alongside familiar binary operations. Software could then be programmed with common sense, intention, and human understanding, such as asking for a real-looking Gmail address without writing a complicated regular expression.

15:22

Reliable agent systems need engineering discipline around decomposition and state

Almeida's proposed software research follows familiar software engineering practices. Engineers should break work into stages and choose stages that can be verified, so each part has real encapsulation. They should manage state explicitly instead of treating everything as global context inside a KV cache. He argues that current agents are constrained by the KV cache and therefore become inflexible or inefficient. Long histories could be searched to decide what matters, agents could share state instead of rediscovering the same codebase patterns, and routing could send work to appropriate subagents. These designs require better ways to retrieve and organize memory.

17:32

Semantic types and real-time intelligence could encode intent

Almeida says many organizational problems come from encoding only literal rules while leaving the intended spirit unspecified. That creates loopholes and incentives to work around the rules. He wants systems that can encode intent and semantic properties. Examples include a type system that checks meaning, a lint checker backed by a Jev-like model, and security systems that can detect harmful behavior in real time. He argues that the obstacle to real-time intelligent security is not necessarily the ability to recognize a bad action. The obstacle is making the intelligence fast, cheap, and reliable enough to run continuously.

19:41

Automation should include playful experiments that test what software can do

Almeida connects unreliable AI to the spread of low-quality generated content. When companies cannot trust AI with costly decisions, they can push the cost of filtering onto other people, which produces slop. He wants systems reliable enough to reduce that externalized burden. He also defends playful and deliberately strange software, including interfaces inspired by bad UI experiments. Only a small fraction of such ideas may become useful, but exploring them is part of software engineering's creative role. He ends by asking what engineers could automate if the current boundaries of software stopped being fixed. The future question may be how much work automation requires, rather than whether automation is possible at all.

"What if we can program with common sense, with intention, with human understanding?"14:03
Who should watch
  • You build AI agents and need them to run work without constant human checking.
  • Your team is adding chatbots or coding agents while the underlying software still cannot make decisions inside its own workflow.
  • You are exploring agent memory, semantic types, real-time security, or unusual software ideas and want a case for machine-native design.