We are programming AI in assembly language

In a Fast Company column, author argues that corporate AI development is stuck at an assembly-language level, requiring engineers to hand-build persistence, memory, permissions, tracing, retries, orchestration, durable execution, tool access, context management, and evaluation. The piece compares this to the pre-web internet era and cites IBM's Fortran history, noting tasks needing up to a thousand machine instructions could be expressed in 47 Fortran statements, suggesting higher-level abstractions are needed for AI to become economically expressible.

In the series of articles I’ve been writing for Fast Company devoted to what I believe corporate https://www.fastcompany.com/91595669/ai-cannot-optimize-a-company-it-cannot-understand AI https://www.fastcompany.com/91595669/ai-cannot-optimize-a-company-it-cannot-understand should be, I’ve been touching on a very provocative idea: Perhaps the biggest problem of corporate AI https://www.fastcompany.com/section/artificial-intelligence as we know it so far is not intelligence, but the level at which we are programming it. As we speak, frontier models, elastic cloud infrastructure, vector databases, managed APIs, and large amounts of computation are available to basically any serious company. As a substrate, this is extraordinarily powerful. However, in order to put AI systems into production, we still require engineers who hand-assemble fundamental things such as persistence, memory, permissions, tracing, retries, orchestration, durable execution, tool access, context management, and evaluation. As we said before, this is like the internet in 1991 https://www.fastcompany.com/91553094/enterprise-ai-is-in-1991-wheres-its-web , before the web was invented. Today, high-level languages—programming languages that use strong abstraction from the computer’s hardware details so that it’s easier for humans to read and write—are normal. However, decades ago, developers had to fight the machine directly, in machine or assembly language, something that John Backus https://urldefense.proofpoint.com/v2/url?u=https-3A en.wikipedia.org wiki John-5FBackus&d=DwMFaQ&c=euGZstcaTDllvimEN8b7jXrwqOf-v5A CdpgnVfiiMM&r=xHenyQfyc6YcuCNMBsOvfYGQILM1d1ruredVZikn4HE&m=Q7K9CNtpcAVfJ8zXM7yfDC0r1UgqYOYSbKcEcP DEm1LHNFhI7-giBCj5B5kgRMw&s=FOp5GFvTPV9zk693Xjz0sCvkfVmhpaYIxeGQElfbIRI&e= described as “ a hand-to-hand combat with the machine https://urldefense.proofpoint.com/v2/url?u=https-3A research.ibm.com publications the-2Dhistory-2Dof-2Dfortran-2Di-2Dii-2Dand-2Diii&d=DwMFaQ&c=euGZstcaTDllvimEN8b7jXrwqOf-v5A CdpgnVfiiMM&r=xHenyQfyc6YcuCNMBsOvfYGQILM1d1ruredVZikn4HE&m=Q7K9CNtpcAVfJ8zXM7yfDC0r1UgqYOYSbKcEcP DEm1LHNFhI7-giBCj5B5kgRMw&s=nj2nM6uL9-002xuRdL5sI3aLGvx5BIGwv9P6 U6S1AA&e= .” In IBM’s history of Fortran https://urldefense.proofpoint.com/v2/url?u=https-3A www.ibm.com history fortran&d=DwMFaQ&c=euGZstcaTDllvimEN8b7jXrwqOf-v5A CdpgnVfiiMM&r=xHenyQfyc6YcuCNMBsOvfYGQILM1d1ruredVZikn4HE&m=Q7K9CNtpcAVfJ8zXM7yfDC0r1UgqYOYSbKcEcP DEm1LHNFhI7-giBCj5B5kgRMw&s=kJ4peZzpOQtSur6bLvVHQizmHS4RDdEecHtXGigD4sw&e= , the company explains there were tasks requiring up to a thousand machine instructions that could be easily expressed in just 47 Fortran statements, while at the same time detaching programs from specific hardware. It is not that Fortran made computation possible, but it definitely made it economically expressible at a higher level. We saw the same pattern with C, Java, or the web. Dennis Ritchie https://urldefense.proofpoint.com/v2/url?u=https-3A en.wikipedia.org wiki Dennis-5FRitchie&d=DwMFaQ&c=euGZstcaTDllvimEN8b7jXrwqOf-v5A CdpgnVfiiMM&r=xHenyQfyc6YcuCNMBsOvfYGQILM1d1ruredVZikn4HE&m=Q7K9CNtpcAVfJ8zXM7yfDC0r1UgqYOYSbKcEcP DEm1LHNFhI7-giBCj5B5kgRMw&s=xQvF6RG4Aj3OtoydDgBTxkeIJgTxYosH7th1CVoqBG4&e= explains how C allowed Unix itself to be rewritten in a largely portable language https://urldefense.proofpoint.com/v2/url?u=https-3A www.nokia.com bell-2Dlabs about dennis-2Dm-2Dritchie chist.pdf&d=DwMFaQ&c=euGZstcaTDllvimEN8b7jXrwqOf-v5A CdpgnVfiiMM&r=xHenyQfyc6YcuCNMBsOvfYGQILM1d1ruredVZikn4HE&m=Q7K9CNtpcAVfJ8zXM7yfDC0r1UgqYOYSbKcEcP DEm1LHNFhI7-giBCj5B5kgRMw&s=UjjIgLZsPHz9Up2Ozf0jw019LlzqY2CehQfiku3pohA&e= , making it easier to move across machines. Later, Java https://urldefense.proofpoint.com/v2/url?u=https-3A docs.oracle.com en database oracle oracle-2Ddatabase 26 jjdev Java-2Doverview.html&d=DwMFaQ&c=euGZstcaTDllvimEN8b7jXrwqOf-v5A CdpgnVfiiMM&r=xHenyQfyc6YcuCNMBsOvfYGQILM1d1ruredVZikn4HE&m=Q7K9CNtpcAVfJ8zXM7yfDC0r1UgqYOYSbKcEcP DEm1LHNFhI7-giBCj5B5kgRMw&s=sS8DyAUbenWBVPITpu-hOK16Tay w6avz2KGHdOV3K4&e= made the JVM plus standard libraries into an explicit platform, starting the “ write once, run anywhere https://urldefense.proofpoint.com/v2/url?u=https-3A en.wikipedia.org wiki Write-5Fonce-252C-5Frun-5Fanywhere&d=DwMFaQ&c=euGZstcaTDllvimEN8b7jXrwqOf-v5A CdpgnVfiiMM&r=xHenyQfyc6YcuCNMBsOvfYGQILM1d1ruredVZikn4HE&m=Q7K9CNtpcAVfJ8zXM7yfDC0r1UgqYOYSbKcEcP DEm1LHNFhI7-giBCj5B5kgRMw&s=tO33V5tEQjt8uwd8KymhDPERisoDHRMjbt2OpRMrvxo&e= ” movement. Then the https://urldefense.proofpoint.com/v2/url?u=https-3A home.cern science computing the-2Dbirth-2Dof-2Dthe-2Dweb short-2Dhistory-2Dweb &d=DwMFaQ&c=euGZstcaTDllvimEN8b7jXrwqOf-v5A CdpgnVfiiMM&r=xHenyQfyc6YcuCNMBsOvfYGQILM1d1ruredVZikn4HE&m=Q7K9CNtpcAVfJ8zXM7yfDC0r1UgqYOYSbKcEcP DEm1LHNFhI7-giBCj5B5kgRMw&s=a-MRHl0kjJZfD55mUcjZwAyqcL4TpAqcD1wlxPCIcbE&e= web transformed an already functional but complex internet https://urldefense.proofpoint.com/v2/url?u=https-3A home.cern science computing the-2Dbirth-2Dof-2Dthe-2Dweb short-2Dhistory-2Dweb &d=DwMFaQ&c=euGZstcaTDllvimEN8b7jXrwqOf-v5A CdpgnVfiiMM&r=xHenyQfyc6YcuCNMBsOvfYGQILM1d1ruredVZikn4HE&m=Q7K9CNtpcAVfJ8zXM7yfDC0r1UgqYOYSbKcEcP DEm1LHNFhI7-giBCj5B5kgRMw&s=a-MRHl0kjJZfD55mUcjZwAyqcL4TpAqcD1wlxPCIcbE&e= by introducing a simple shared grammar HTML, HTTP, and URLs on top of the network substrate. In all these cases, the infrastructure existed beforehand, but the abstraction made it easily programmable and manageable. Today’s agentic stack looks a lot like another pre-language period: We use Python plus frameworks and services to program intelligent applications, with each piece managing fundamental characteristics separately. None of these products is unnecessary—quite the opposite—but their proliferation is also evidence that an underlying abstraction may still be missing. What happens when an ecosystem grows around individually supplying properties the substrate does not naturally provide? Quite simply, the ecosystem can start to be read as a sort of itemized invoice for a missing layer. Think about LangChain https://urldefense.proofpoint.com/v2/url?u=https-3A en.wikipedia.org wiki LangChain&d=DwMFaQ&c=euGZstcaTDllvimEN8b7jXrwqOf-v5A CdpgnVfiiMM&r=xHenyQfyc6YcuCNMBsOvfYGQILM1d1ruredVZikn4HE&m=Q7K9CNtpcAVfJ8zXM7yfDC0r1UgqYOYSbKcEcP DEm1LHNFhI7-giBCj5B5kgRMw&s=RBJYfT3ZVWuuksDswdXO3iuo7vGHrudIf4jQO46S9kU&e= , for instance: It explicitly distinguishes the harness around an agent from the runtime underneath it. They say production agents have requirements such as durable execution, memory, multi-tenancy, human-in-the-loop, observability, sandboxes, integrations, and scheduling. And they themselves explain https://urldefense.proofpoint.com/v2/url?u=https-3A www.langchain.com blog runtime-2Dbehind-2Dproduction-2Ddeep-2Dagents&d=DwMFaQ&c=euGZstcaTDllvimEN8b7jXrwqOf-v5A CdpgnVfiiMM&r=xHenyQfyc6YcuCNMBsOvfYGQILM1d1ruredVZikn4HE&m=Q7K9CNtpcAVfJ8zXM7yfDC0r1UgqYOYSbKcEcP DEm1LHNFhI7-giBCj5B5kgRMw&s=dg-i-SZPjQlwDKBNMRG xZEoRbfMxcwPg7yvrkLFrT4&e= that “to build a good agent, you need a good harness; and to deploy that agent, you need a good runtime.” Does this give you a clue? One more example, Temporal https://urldefense.proofpoint.com/v2/url?u=https-3A temporal.io &d=DwMFaQ&c=euGZstcaTDllvimEN8b7jXrwqOf-v5A CdpgnVfiiMM&r=xHenyQfyc6YcuCNMBsOvfYGQILM1d1ruredVZikn4HE&m=Q7K9CNtpcAVfJ8zXM7yfDC0r1UgqYOYSbKcEcP DEm1LHNFhI7-giBCj5B5kgRMw&s=Kdos5bD014iuYLekHqsRMEUOk9IZr7bfpkV7KeRD4MI&e= , gives us another clear signal: They raised $300 million in February at a $5 billion valuation https://urldefense.proofpoint.com/v2/url?u=https-3A temporal.io news temporal-2Draises-2D300M-2Dto-2Dmake-2Dagentic-2Dai-2Dreal-2Dfor-2Dcompanies&d=DwMFaQ&c=euGZstcaTDllvimEN8b7jXrwqOf-v5A CdpgnVfiiMM&r=xHenyQfyc6YcuCNMBsOvfYGQILM1d1ruredVZikn4HE&m=Q7K9CNtpcAVfJ8zXM7yfDC0r1UgqYOYSbKcEcP DEm1LHNFhI7-giBCj5B5kgRMw&s=kMWDWkJM7EEmZCLt2vqIQJ3Xai74XBixTy uIwS4mnw&e= , selling the idea that long-running, stateful AI applications need a durable execution layer, which is true. But in their reference architecture https://urldefense.proofpoint.com/v2/url?u=https-3A go.temporal.io platform-2Dhub ai-2Dengineering ai-2Dreference-2Darchitecture&d=DwMFaQ&c=euGZstcaTDllvimEN8b7jXrwqOf-v5A CdpgnVfiiMM&r=xHenyQfyc6YcuCNMBsOvfYGQILM1d1ruredVZikn4HE&m=Q7K9CNtpcAVfJ8zXM7yfDC0r1UgqYOYSbKcEcP DEm1LHNFhI7-giBCj5B5kgRMw&s= qa7klXnvPmwguXDB5zgdN0EP m9cs5VN1rtEogsszw&e= , LLM calls and external side effects need to be wrapped carefully so that workflow state remains replayable and recoverable. That’s sophisticated, for sure, but also proof that we are still manually assembling primitives that a future AI-native runtime might reasonably make intrinsic. How about LangGraph https://urldefense.proofpoint.com/v2/url?u=https-3A reference.langchain.com python langgraph&d=DwMFaQ&c=euGZstcaTDllvimEN8b7jXrwqOf-v5A CdpgnVfiiMM&r=xHenyQfyc6YcuCNMBsOvfYGQILM1d1ruredVZikn4HE&m=Q7K9CNtpcAVfJ8zXM7yfDC0r1UgqYOYSbKcEcP DEm1LHNFhI7-giBCj5B5kgRMw&s=0-d2zVXiyon0bKxFA0c8gDyP6lqFajm8ikHLUjt3pmg&e= , or even Anthropic https://urldefense.proofpoint.com/v2/url?u=https-3A www.anthropic.com engineering effective-2Dharnesses-2Dfor-2Dlong-2Drunning-2Dagents&d=DwMFaQ&c=euGZstcaTDllvimEN8b7jXrwqOf-v5A CdpgnVfiiMM&r=xHenyQfyc6YcuCNMBsOvfYGQILM1d1ruredVZikn4HE&m=Q7K9CNtpcAVfJ8zXM7yfDC0r1UgqYOYSbKcEcP DEm1LHNFhI7-giBCj5B5kgRMw&s=j5HxaLkMTqGJbJ1fVsx8vwPvdDWVewHtQkHW97FTRik&e= ? They tell the same story from different angles. As we can see, the current stack can build almost anything . . . but at a significant cost. And the cost, as it happened a long time ago with assembly, is extraordinary complexity. You could do incredible software with assembly, sure, but the engineering cost, fragility, and lack of a reusable abstraction forced us to essentially reinvent the wheel. Every. Single. Time. Nowadays, with Python + databases + queues + orchestration + tracing + memory stores, we can absolutely produce excellent AI systems . . . but every team has to solve the same problems over and over again. As I said before, metaphors do not industrialize https://www.fastcompany.com/91555415/real-reason-enterprise-ai-stuck . In order to make software truly industrial, we need to follow capability with formalization. Examples? Codd’s relational model https://urldefense.proofpoint.com/v2/url?u=https-3A en.wikipedia.org wiki Relational-5Fmodel&d=DwMFaQ&c=euGZstcaTDllvimEN8b7jXrwqOf-v5A CdpgnVfiiMM&r=xHenyQfyc6YcuCNMBsOvfYGQILM1d1ruredVZikn4HE&m=Q7K9CNtpcAVfJ8zXM7yfDC0r1UgqYOYSbKcEcP DEm1LHNFhI7-giBCj5B5kgRMw&s=zFRK7Y86q3JWmdI2XauK1hOPEfeGppnaGHMw5Zl89W4&e= appeared before the database ecosystem. Web standards preceded the web economy. And ERP https://urldefense.proofpoint.com/v2/url?u=https-3A en.wikipedia.org wiki Enterprise-5Fresource-5Fplanning&d=DwMFaQ&c=euGZstcaTDllvimEN8b7jXrwqOf-v5A CdpgnVfiiMM&r=xHenyQfyc6YcuCNMBsOvfYGQILM1d1ruredVZikn4HE&m=Q7K9CNtpcAVfJ8zXM7yfDC0r1UgqYOYSbKcEcP DEm1LHNFhI7-giBCj5B5kgRMw&s=x8cMrBmj1PEfQqnONwJir76xmMqjSxGqd25MS64g1Uo&e= created the shared enterprise abstractions we still use. Formalization has to reach the runtime itself at some point. Things as important as memory, state, permissions, workflows, journaled execution, and learning need to become primitives, instead of libraries glued together afterward. What properties should be guaranteed by construction? When writing conventional software, developers don’t have to implement things manually such as virtual memory, process scheduling, or file system semantics for every single application. When a substrate becomes mature, it becomes able to provide them with such properties automatically. But for some reason, when we are struggling to develop enterprise AI, we still end up treating things as important as persistent agent identity, governed access, structured histories, and learning signals as one-of-a-kind problems to be solved each time on a case-by-case basis. This makes no sense at all: All these things should be properties of the runtime, not external products that we have to manually assemble each time as if we were artisans. This becomes pretty obvious when you check where startups are appearing: Look how things such as memory, durable execution, observability, sandboxing, guardrails, agent identity, and orchestration are all becoming categories of their own, with companies that pop up like mushrooms and raise interesting amounts of money. That’s essentially good for entrepreneurs and for the ecosystem, I guess, but historically, it is an early sign that precedes abstraction. Will all these layers be permanently independent, or are we watching an industry temporarily sell separately the pieces that a future runtime will eventually absorb and fuse all together? Do you know what’s extraordinary about the current corporate AI era? That we have already built the equivalent of the mainframe, the network, and the computing cloud, but we are still programming most of the intelligent layer purely by hand, line after line, with blood, sweat, and tears. When developers look at today’s intricate Python wrappers, checkpoint databases, queues, tracing systems, memory stores, and orchestration graphs in the future, they will see them in the same way we see early assembly listings now: amazing, laborious, impressive for their time, and astonishing because all that complexity was at some point in time considered necessary. Think about it with a historical perspective: If every major computing substrate eventually ended up acquiring a language and a runtime expressing its native abstractions, why should artificial intelligence be different? You can think of it as a thought experiment, or a wild desire: What would such a runtime actually have to make native to become the platform of your dreams, the one that would make your corporate AI implementations much easier? For now, that is the interesting question. But eventually, it may become more than just a thought experiment.