There Is No AI Agent

Revised since first publication. Material changes are dated at the end.

TLDR

• AI systems are tools, not creatures. Large language models are software modules executing human instructions. Calling them "agents" is corporate myth-making that obscures who is legally liable when systems break.
• Why chatbots fail at real work. Generating text word-by-word is too slow, erratic, and expensive for production backends. Reliable automation treats machine learning as a fast, narrow decision-maker restricted to predefined options inside standard code.
• The cross-discipline bridge. Managing an unpredictable AI script is the exact same dilemma early Arabian merchants faced fourteen hundred years ago when sending caravans across the desert: how to delegate power without losing control. Classical commercial law solved this through shared-risk partnerships (qirâd) and the strict outlawing of hidden, speculative gambles (gharar).
• The convergence. Modern software engineering and ancient legal architecture arrive at the same destination: an algorithm has no soul and cannot bear liability. Reliable systems demand strictly bounded actions, cryptographic receipts, and human stewards who remain fully accountable.

On a Tuesday afternoon in Kuala Lumpur, I was debugging a webhook receiver that had silently dropped thirty-two transactions during a mid-day traffic spike.

The payment gateway had cleared the funds, but the partner's callback endpoint timed out after four seconds, leaving thirty-two customers charged and zero orders written to the fulfillment database. I wrote a SQL script in BigQuery to isolate the orphaned gateway transaction IDs, cross-referenced them against the bank settlement logs, and queued them into an idempotent retry worker.

A few terminals over, a Playwright automation script was spinning up in a container. Twice a month, it logs into a state statutory zakat portal to submit eight hundred salary-deduction records, handling session timeouts, CSRF tokens, and multipart uploads that used to take hours of manual keying.

I build and maintain automated backend pipelines and payment infrastructure for platforms handling religious financial obligations: zakat, charitable endowments, and religious welfare.

When you spend your working life inside the plumbing of financial obligations, you develop a visceral allergy to Silicon Valley mysticism.

Right now, the technology industry is in the grip of a theological fever. Venture capitalists and model labs speak about "autonomous AI agents" in the hushed, reverent tones once reserved for demiurges. We are told that we are on the verge of creating autonomous synthetic entities: digital persons that will negotiate contracts, allocate capital, and manage infrastructure without human intervention.

This framing is an illusion. Worse, it is an evasion.

Lanier, in the clip above:

"Part of the ideology that makes AI into a creature instead of a collaboration also wants to think of bits as being this ethereal thing that's free and infinite. You show me a bit that didn't involve work. You show me a bit that didn't disperse heat... Information is physical or it's nothing. You can think of large language model AI as a whole bunch of people whose work was combined into this single document. But why do people want it to be a creature? You're a young man. You think you're the center of the universe. Of course you think you're making God." [1]

Lanier's critique cuts to the bone: There is no AI. There are only people, whose labor has been scraped and compiled into a statistical mirror.

When software executives personify the model, when they call a next-token predictor an "agent" and pretend it possesses intention or will, they are performing an ancient sleight of hand. They erase the millions of human writers, programmers, and labeling workers whose work made the weights possible: what Lanier calls the crisis of data dignity. And they erase their own legal and financial liability when the system fails.

If an algorithm hallucinates a bad medical triage recommendation, drops a customer's payment, or signs a ruinous commercial lease, the vendor shrugs: The agent made an autonomous decision. The model is a non-deterministic black box.

In classical Islamic thought, this evasion has a precise name: talbis (counterfeiting: dressing up an illusion to obscure a material reality).

A machine has no ruh (soul), no iradah (moral will), and no dhimmah (legal personhood). It cannot bear an amanah (a sacred trust), because an inanimate artifact cannot be held to moral account before God or man. Attributing agency to silicon is idolatry.

Yet the practical demand for automation has never been greater.

If we reject the Silicon Valley fantasy of the AI "creature," how do we actually build automated systems that move money, process sensitive records, and execute workflows at scale?

The answer requires two things that Silicon Valley currently lacks:

1. An honest software engineering discipline that recognizes models as software modules rather than digital beings: compiler targets, fuzzy classifiers, and probabilistic decision gates embedded into deterministic code.
2. A classical commercial legal architecture that has already solved the problem of delegating high-stakes, long-distance agency without central state monopolies.

The technical tools are already running in open source. Their legal and institutional blueprint was engineered fourteen hundred years ago in the commercial society of early Mecca and Medina.

1. Where Is the Automation? The Model Is Just Software

For four years, the tech industry has operated under a bizarre assumption: that the path to business automation runs through chat interfaces and open-ended generative text.

Diogo Almeida, an early researcher at OpenAI who helped build the reinforcement learning methods behind ChatGPT, asked the obvious question when introducing TypeSafe AI:

"Models have been superhuman at chat for years, so where is all the automation?" [2]

If large language models are so brilliant, why are businesses still manually reconciling spreadsheets, copying data between portals, and paying rooms full of people to check forms?

The bottleneck is architectural.

Generative large language models are autoregressive token predictors. They output strings: one character or word at a time, each conditioned on the last. Strings are flexible for conversation and open-ended drafting.

For software automation, strings are a disaster.

When you embed a generative LLM inside a production software loop, four things go wrong:

1. Latency: Generating tokens sequentially takes anywhere from 3 to 300 seconds. That is acceptable if a human is reading a chatbot response. It is fatal inside an automated backend workflow.
2. Hallucination and Type Errors: Strings have no guardrails. A model instructed to output JSON can drop a bracket, invent an imaginary enum value, hallucinate an API parameter, or inject a conversational refusal into a payload. In a deep software dependency chain, a single malformed token crashes the pipeline.
3. Epistemic Dishonesty: LLMs are notoriously overconfident. A model will state a false claim with the exact same linguistic certainty as a verified fact. It cannot tell software when it is guessing.
4. Economics: Autoregressive sampling consumes massive GPU compute, driving token costs to levels that obliterate the margins of the business running it.

This is why most "AI agent" startups stall at the demo stage. They build wrappers around open-ended chat prompts, discover that the agent derails three percent of the time, and realize that a three percent catastrophic failure rate makes a system un-deployable in banking, logistics, or healthcare.

The realization taking root across engineering is simpler: an LLM is software, not an agent.

It is an array of floating-point numbers performing mathematical function approximation. When you stop asking it to be a conscious digital employee, you begin treating it as an engineering primitive: a fast, fuzzy classifier that converts unstructured data into typed program state.

We are seeing this architectural pivot break out around TypeSafe's early-access Jev, and reactions to it:

TypeSafe's System One Models (Jev): TypeSafe has built one of the cleanest commercial implementations of this pattern, and Jev is still in early access. Instead of generating sequential strings, it was trained for parallel structured decisions. The model takes unstructured program state in, and outputs typed categorical decisions in 70 milliseconds with zero syntax errors, because the output space is mathematically constrained at compile time to predefined schemas. [2]

Browser-Use's Jev-Ultrafast: A Jev-powered use case, built on the early-access API. In real-world browser automation, the team at Browser-Use demonstrated how clean the separation becomes. Rather than letting an LLM generate brittle natural-language scripts or slow visual coordinates, they indexed the DOM controls into an action space. A fast structured decision head picks the operation (click, select, wait) and element index in a single network round-trip. In their published measurements for jev-ultrafast, browser protocol calls dropped from 1,092 to 101, and median task time from 9.450s to 7.092s, with a live Google Flights search completing in 7.1 seconds. Generative text models are only summoned if actual text needs to be typed into an input field. [3]

Independent reimplementations (jevlike and open-jev): These two are not Jev, and have no affiliation with TypeSafe. They rebuilt the same input-output shape from the published contract, without ever seeing Jev's design. Vinny Larouge's jevlike pairs an option-attention head with a small, frozen open-weights encoder (such as Qwen 2.5 0.5B) to score discrete choices in a single forward pass, at roughly 100x the speed of a small decoder forced to write 400 tokens. [4] Dasein Labs' open-jev implements the System One contract on local Apple Silicon via MLX, scoring structured queries at roughly 86 milliseconds per example on consumer hardware without emitting a single hallucinated token. [5]

That last pair matters more than the numbers. They show the shape can be rebuilt from a published contract by people who could not see the original. They do not show that they match Jev, and their authors say so. Everything in this section is early: Jev is early access, the benchmarks are self-reported by each project, and the reimplementations are research starters, not products.

What does this wave of experimentation prove?

It proves that we are in the earliest stages of demystifying the model.

When you treat machine learning as software, you decompose the problem properly:

• Deterministic code handles control flow, state persistence, database transactions, and network retries.
• Fast, typed classification heads handle fuzzy categorical decisions and intent routing.
• Generative strings are reserved strictly for communicating with human beings.

This is what automation actually looks like: a strictly bounded, type-safe function call embedded in human-authored code, not a synthetic creature roaming the web.

2. The Ancient Agency Problem: Delegation Across the Desert

Strip away the science-fiction terminology and an "agent" is simply delegated software executing instructions with capital and access. The machine learning problem disappears; the institutional agency problem takes over.

How does a principal delegate resources and operational authority to an agent who operates outside direct supervision, in an environment fraught with uncertainty, without allowing the agent to embezzle capital or shirk responsibility?

In his work Early Islam and the Birth of Capitalism, Benedikt Koehler demonstrates that this was the foundational economic problem of early Arabia. [6]

Consider the sixth-century Meccan caravan.

Mecca sat at the crossroads of regional trade routes, with no agriculture and no manufacturing. Its entire economy depended on organizing massive, capital-intensive trade caravans to Yemen, Syria, and Abyssinia. A single caravan could aggregate millions of dirhams of capital from hundreds of individual investors, assemble thousands of camels, and march across thousands of miles of hostile desert for six months.

The caravan was completely disconnected from the investors who funded it. There were no telegraphs, no banks, no police, and no sovereign state standing over the desert. Once the caravan departed Mecca, the managing merchant operated with absolute operational autonomy.

Under Roman law and European feudalism, long-distance delegation was fragile. Roman commercial law relied heavily on enslaved managers (servi institores) because an enslaved person had no independent legal standing and could be subjected to physical coercion to compel an accounting. Feudal Europe relied on personal oaths of vassalage backed by territorial violence.

Early Islamic society had neither imperial courts nor feudal serfdom. It solved the agency problem through legal and contract engineering: the qirâd.

The Invention of Venture Capital: The Qirâd

The instrument that enabled caravan trade was the qirâd (also known as mudaraba).

Under a qirâd contract, an investor (such as Khadija bint Khuwaylid, who famously financed the young Muhammad's early caravan ventures) provided capital to an active commercial manager. The legal structure was explicit:

• The investor bore the financial risk. If the caravan was raided or market prices collapsed through genuine misfortune, the investor absorbed the capital loss.
• The manager contributed labor and skill. If the venture failed, the manager lost their time and effort, but was not plunged into debt or bondage.
• Profits were shared according to a strictly pre-negotiated equity ratio.
• Fixed returns were strictly forbidden. Charging a guaranteed interest rate (riba) on a commercial venture was outlawed, because it decoupled the investor's return from the actual operational reality of the enterprise, forcing all downside risk onto the working operator.
• If the manager violated the mandate, mingled investor funds with personal assets, or acted with negligence, the limited liability vanished. The loss converted immediately into a personal liability owed by the manager.

As Koehler demonstrates, this institutional technology did not stay in the desert. Arab traders carried it across the Mediterranean. In the merchant republics of Amalfi, Genoa, and Venice, the qirâd was adopted directly as the commenda. [6]

Venetian notarial archives show maritime voyages financed under commenda contracts where investors and ship captains joined ad risicum et fortunam (to risk and fortune). That contract is the historical origin of the Western word risk (risicum): the formal acknowledgment that upside and downside are irrevocably paired. [6]

The modern venture capital fund, where limited partners provide capital and general partners provide execution for a share of the carry, is the direct descendant of the Meccan caravan qirâd.

Now look at how the modern AI industry structures agent automation.

Platform monopolies and enterprise aggregators attempt to monetize automation through extractive, risk-free rents: selling per-seat licenses, charging monthly platform fees, and passing through compute costs regardless of whether the automated workflow generates verified value for the client. [11] When Meta introduced its Business Agent on WhatsApp while shifting customer service messaging to paid tiers, it acted as a digital landlord: tolling the communication channel while leaving all operational and commercial risk with the merchant. [7][8]

The native model for automated enterprise services is the qirâd.

An automation provider should not levy a fixed tax on human labor. If structured under the principles of the qirâd, automated services would take compensation strictly from the efficiency they verifiably create: operating within explicit mandate boundaries, with the human enterprise deploying them bearing immediate and undivided liability whenever the system breaches its constraints.

3. Eliminating Gharar: Deterministic Bounds over Probabilistic Gambles

This brings us to the core legal and ethical principle that modern AI engineering violates every single day: the prohibition of Gharar.

In classical Islamic commercial jurisprudence, gharar is the prohibition of contracts characterized by excessive uncertainty, hidden hazard, or non-verifiable execution.

Classical jurists defined gharar with vivid material examples: selling birds in the sky, fish still swimming in the sea, or the unborn calf in a camel's womb. Why? Because the seller cannot guarantee delivery, the buyer cannot verify what they are purchasing, and the transaction is speculative. [6]

Now examine how generative AI agents are deployed in enterprise software today:

A company connects an open-ended, non-deterministic language model directly to an external database or API via a fuzzy prompt. The model is given instructions to negotiate discounts, manage refunds, or trigger payments.

This is the purest modern manifestation of gharar.

The principal cannot verify what the model will do in advance. The client cannot guarantee that the model will not hallucinate an unauthorized price or trigger a destructive tool call. The entire interaction rests on a probabilistic roll of the dice.

Silicon Valley calls this "agentic autonomy."

Islamic commercial law calls it a void contract (aqd batil). You cannot enter into a valid commercial commitment where the terms of execution are hidden in a probabilistic fog.

Enforcing deterministic settlement boundaries solves gharar without abandoning machine learning:

First, type-safe decisions replace probabilistic generation. This is why the System One architecture matters. When an algorithm operates on a strictly typed action space, like open-jev or Browser-Use's jev-ultrafast, the set of possible actions is mathematically bounded at compile time. [3][5] The model can choose which valid button to press, but it cannot hallucinate a button that does not exist.

Second, every automated action must emit a signed receipt. In early Islamic commerce, long-distance transfers were authenticated using the saqq (the signed financial order that gave English the word cheque) and the suftaja (the promissory bill of exchange). [6] An automated system cannot simply execute an action and log a text string to a transient console. It must produce a cryptographically signed execution record verifying what input was observed, what calibrated confidence was returned, what deterministic rule was evaluated, and which human principal authorized the state change.

Third, the human steward remains strictly liable. In Islamic law, genuine agency (wikalah) requires legal personhood (dhimmah). An algorithm cannot be an agent (wakil); it is an inanimate instrument (âlah). Because an instrument has no moral or legal standing before a court, the human organization that deployed it carries one hundred percent of the financial and moral liability. You cannot sue an algorithm. If an automated script drops an order, overcharges a customer, or misroutes a delivery, liability does not evaporate into the model weights; it stops entirely with the human steward who ran it.

Type safety and deterministic execution mathematically eliminate gharar from software.

4. Beyond Silicon Valley Eschatology

On the fringes of the modern tech scene, another ideology has taken hold: an accelerationist eschatology that treats artificial intelligence as the successor species to humanity.

Tech executives publish manifestos about building digital gods in server farms. Transhumanists speak about merging human consciousness with synthetic superintelligence, while doomers obsess over apocalyptic paperclip-maximizers that will extinguish life from the planet.

If you read the classical treatises on Islamic eschatology (the Kutub al-Fitan, such as Nu'aym ibn Hammad's Kitab al-Fitan on ghayb.com), you discover a striking psychological symmetry. [9]

In traditional Islamic sources, the defining trial of the End Times is deception (fitnat al-Dajjal), not physical destruction alone.

The classical texts describe the archetypal deceiver as an architect of total illusion: an entity that travels the earth with unnatural speed, conjures false abundance, and projects hollow paradises. Read in our time, it is an unmistakable warning against surrendering moral sovereignty to the spectacle of artificial power. [9]

What is the core intellectual deception of our era?

It is the belief that by assembling enough compute, scraping enough human text, and optimizing enough matrix multiplications, we can generate a soul (ruh). It is the belief that moral responsibility can be offloaded to an algorithm, and that human labor can be appropriated without compensation. It is the delusion that the unseen world (Al-Ghayb) can be conquered by statistical inference.

The Quran establishes an unbreachable ontological boundary:

"And they ask you concerning the Spirit (al-Ruh). Say: The Spirit is of the affair of my Lord, and of knowledge you have been given but a little." (Surah Al-Isra, 17:85) [10]

Silicon will never possess a soul. It will never feel the terror of accountability before its Creator, it will never know compassion, and it will never bear moral weight.

An algorithm does not understand Al-Ghayb (the Unseen). An LLM is an interpolation of the past: a statistical compression of the digital footprint left behind by human beings who lived and worked before the training cutoff date. It knows nothing of the future, nothing of transcendent truth, and carries no moral reality.

Treating a model as an autonomous oracle is a category error. The task is treating software with ruthless, sober realism, without bowing to synthetic creatures.

5. The Return to the Terminal

Back at the desk, the terminal clears.

The reconciliation worker finishes its loop. Thirty-two dropped transactions are patched, verified against the gateway ledger, and receipted. The Playwright container shuts down cleanly, its batch confirmed by the state portal.

The work is unglamorous.

There are no synthetic creatures here. There is no artificial general intelligence whispering secrets about the cosmos.

There is only code: written by human hands, executing on physical silicon powered by a municipal grid, moving real money to real human beings who need it.

The real test is keeping the machine in its proper place: an instrument of human stewardship (amanah), stripped of magical thinking, bounded by deterministic code, verified by honest accounting, and held strictly accountable under human law.

Fourteen hundred years ago, in the markets of Mecca and Medina, merchants and jurists built the institutional foundation for a decentralized, accountable economy that could operate across vast geography without imperial tyranny.

Stop waiting for digital gods. Compile honest software.

1. Jaron Lanier, in conversation with Neil deGrasse Tyson, StarTalk: "Why We Treat AI Like a God," clip at https://www.youtube.com/watch?v=XMNpjb3LPlY; full episode at https://www.youtube.com/watch?v=TTppvBU2rU4
2. Diogo Almeida, "Introducing System One Models & Jev," TypeSafe AI blog. https://typesafe.ai/blog/introducing-system-one-models-and-jev
3. browser-use, jev-ultrafast, README and performance notes. https://github.com/browser-use/jev-ultrafast
4. vinnylarouge, jevlike, README and architecture notes. https://github.com/vinnylarouge/jevlike
5. daseinlabs, open-jev, README and design notes. https://github.com/daseinlabs/open-jev
6. Benedikt Koehler, Early Islam and the Birth of Capitalism (Lexington Books, 2014). Chapters 4, 14, 15, 19 and the conclusion for the Medina market, the qirâd/commenda, the waqf, and gharar respectively.
7. Meta, "Upcoming pricing updates for Meta Business Agent, service and utility messages," WhatsApp Business Platform documentation. https://developers.facebook.com/documentation/business-messaging/whatsapp/pricing/non-template-messages
8. Meta, "Pricing on the WhatsApp Business Platform." https://developers.facebook.com/docs/whatsapp/pricing
9. Nu'aym ibn Hammad, Kitab al-Fitan, as collected at ghayb.com/nuaym-ibn-hammad-kitab-al-fitan.
10. Qur'an 17:85 (Surah Al-Isra). Translation standard, lightly normalised.
11. "The Unicorn Gap," on platform pricing and incumbency. https://zak.im/the-unicorn-gap/

Fact notes. The opening scene is a composite of routine operational work, not a reconstruction of one dated incident; the system described, the reconciliation pattern, and the portal automation are real and recurring. Koehler's thesis that Islamic commercial practice transmitted specific institutions to Europe is a historian's argument, contested in part: Abraham Udovitch's "At the Origins of the Western Commenda" asks the transmission question rather than asserting it, and the linguistic evidence is circumstantial. Lanier's remarks are quoted from the episode's auto-generated captions, lightly punctuated for readability. The TypeSafe performance figures are vendor-published, and the open-source figures are self-reported by their authors; neither has been independently benchmarked here. The framing of fitnat al-Dajjal as a critique of technological hubris is one reading of the tradition, not a ruling. Corrections and counter-arguments are welcome: [email protected].

Revision notes. 19 Sep 2026: narrowed Jev claims (early-access status, self-reported benchmarks, and independent open-source reimplementations); added StarTalk, Jev, and Financial Times video references; pointed the Kitab al-Fitan citation at Nu'aym ibn Hammad; tightened Islamic legal terminology on agency (wikalah/âlah) and undivided human liability; adjusted citation placement on platform rents; aligned the StarTalk clip and episode citations; fixed list formatting and footnote anchors.