John Searle devised his famous Chinese Room thought experiment in response to what he called strong AI. This wasn’t the idea of human-like or superhuman artificial general intelligence (AGI) tech CEOs rave about, but the idea that machines that behave as though they think truly think. One reason these ideas were entertained at the time was that the frontier of artificial intelligence was symbolic rather than numerical, meaning that systems were structured according to formal grammar and logic¹. A scholar who thinks about rules underpinning language all day may be attracted to the idea of a rule-based system that itself thinks. It’s less compelling to imagine that a concatenation of matrix multiplications and other computations understands the sequences of tokens it builds.

I won’t go into detail about the thought experiment, though I’d encourage you to read it in the original article. The basic idea is that someone can produce convincing text-based answers to questions in a language they know nothing about without understanding the questions or answers. All they need are exhaustive formal rules in a language they do know about, on how to respond to sequences of — to them — meaningless symbols.

Because software that lived up to Searle’s room was never actually built², it benefits from an undefined scale. A single person can plausibly follow the potentially vast set of rules because no one formalised them. Due to the number of computations involved in frontier LLM inference and the limited speed at which people can perform arithmetic operations, the subject would need to live for around 380,000 years to generate a token in a conversation with a chatbot. ³ Constrained by human lifetimes, the computation would need to be carried out by a deeply rigid and dogmatic civilisation organised around the purpose of ingesting and producing holy numbers. Even such a dystopia, similar in size to 19th-century England, using telegraph to communicate would produce only five tokens a year. ⁴

I'm not the first to scale this idea up to population size. Ned Block got there before Searle even wrote his paper: his 1978 “China Brain” imagined the entire population of China, linked by radio, simulating a brain neuron by neuron. Searle himself later answered the connectionists with a “Chinese Gym”: a hall of monolingual English speakers hand-cranking a neural network. So the move I'm making here is a well-worn one. What's changed is that the machine on the other side of the analogy now actually exists, which means the scale is no longer a matter of taste: we can put numbers on it.

Let's circle back to Searle's point about incomprehension. I'll try to sketch it out. The scribes or human computers carrying out the calculation wouldn't know what the numbers meant or what they corresponded to. Those privileged few who could access the vaults where the consecrated weight numbers and numbers for divined and generated tokens were stored would not know what symbols the numbers mapped to. The high-ranking bureaucrats who organised inference computation would blindly follow a kind of bureaucratic scripture: their command and control infrastructure operating in the spirit of the Soviet factories that, graded on tonnage, produced chandeliers heavy enough to tear down ceilings, and nail plants that met their quotas with a handful of railway-spike-sized nails.

Scientists caught researching the inference process or building mechanical computers would be publicly executed as heretics. Those who pursued their research in secret would live lonely lives, questioning the consistency of the system they were enmeshed in but lacking a solid basis for any conclusions. Even during the great conjunctions that occur once a generation, the seers who divined new input token numbers from the entrails of sacrificial animals would not know what the numbers meant.

So there it is: an updated Chinese Room, in all its absurdity. It works better as an illustration of just how big large language models are than as a thought experiment. Searle's room has the advantage of not being a closed system, where questions and answers can simply pass under the door. My civilisation has to smuggle its inputs in through an oracle: the divination.

1. This is now known as GOFAI: good old-fashioned AI, a term coined by the philosopher John Haugeland in 1985. Think of SHRDLU, which parsed typed English commands to manipulate a virtual world of coloured blocks; MYCIN, which diagnosed blood infections by chaining through roughly 600 hand-written if-then rules; or Cyc, a decades-long attempt to hand-code common sense as millions of logical assertions. Or ELIZA, the 1966 chatbot that parodied a Rogerian psychotherapist using simple pattern-matching rules, fooling some users into feeling understood, which is precisely the illusion Searle was attacking.

2. This kind of symbolic AI Searle was talking about didn’t make it past R&D, let alone being deployed commercially on a planetary scale like generative AI is today. Despite some early hype, research into expert systems and the like was eventually abandoned, leading to the second AI winter starting in the late 1980s.

3. GPT-4.5, which passed the Turing test most of the time in a 2025 study, had hundreds of billions of parameters; OpenAI never disclosed a figure, but following an educated guess let’s say 600 billion active parameters. Assuming two computations for each parameter to generate a token, it would take an immortal, tireless human 3,169 years to complete a single layer of the transformer that drove GPT-4.5. A single token would take at least 380,000 years. This is based on 0.1 arithmetic operations per second for a human scribe.

4. A significant amount of computation that a transformer does is embarrassingly parallel: the vanilla feed-forward neural network that follows the self-attention magic. This could be parallelised across a galaxy if it weren’t for the speed of light nullifying any parallel gains with a huge communication cost. Barring a mega-structure like a Dyson sphere, the distances signals would need to travel within a solar system for each layer of a transformer would be prohibitive. Within a single small landmass, however, batches of computation can be sent by telegraph to outlying population centres very quickly. A core city of 1 million scribes working around the clock in two 12-hour shifts, 10 million more spread across the land, could generate a GPT-4.5 token in just over two months. See the diagram below for an illustration of this. See also this website for a useful illustration of how transformers and LLMs work.

=====================================================================================

                    O N E   T O K E N   B Y   T E L E G R A P H

             the forward pass at city scale: a capital, its towns, a wire

=====================================================================================

  model      600 B parameters, 120 sequential layers, d_model 20,412
  payload    one hidden state = 20,412 values x 16 bit  ~=  327 kbit
  the wire   100 bit/s telegraph, signals at 0.7c -- the 300 km costs a
             millisecond and a half of flight and hours of keying; at this
             scale bandwidth is the tyrant, never the distance


         _
        /_\       +
   +   |(+)|     _|_
  /_\  | : |    /   \      +                ~ 300 km of wire ~
  | |  | : |   /     \    /_\   ~        ,       ,       ,       ,          +
  | |  | : |  /       \   | |  ~        -+-------+-------+-------+-        /_\
 _| |_ | : | |         |  | |   _  _     |       |       |       |   /\    | |   /\
 | : | | : | |  :: ::  | _| |_|    |     |       |       |       |  /__\  _| |_ /__\
 | : | | : | |  :: ::  | | : || [] |     |       |       |       |  |[]|  | : | |[]|
_|___|_|___|_|_________|_|___||____|_____|_______|_______|_______|__|__|__|___|_|__|_

            C A P I T A L                     the telegraph            T O W N S
       1,000,000 core scribes         100 bit/s, signals at 0.7c   10,000,000 scribes


-------------------------------------------------------------------------------------
                     ONE LAYER  --  k of 120, strictly in order
-------------------------------------------------------------------------------------

  clock         CAPITAL (core)                             TOWNS (periphery)
            1e6 scribes, 10 km wide                     1e7 scribes, 300 km out
    .                  |                                           |
 +0.0 h    +-----------+-----------+                               |
    .      | SELF-ATTENTION        |                               |
    .      | half the city on duty |                               |
    .      | (two 12-hour shifts)  |                               |
    .      | core only: every desk |                               |
    .      | may read the whole    |                               |
    .      | token census          |                               |
    .      |  9.4 h arithmetic     |                               |
    .      | +1.8 h keying across  |                               |
    .      |  the city's own wires |                               |
+11.3 h    +-----------+-----------+                               |
    .                  |                                           |
    .                  |          MLP inputs for layer k           |
+11.3 h                |------- 327 kbit ~ 0.9 h of keying ------->|
    .                  |       (300 km of light-lag: 1.4 ms)       |
    .                  |                                           |
+12.2 h    +-----------+-----------+                 +-------------+-------------+
    .      | MLP: capital's share  |                 | MLP FEED-FORWARD          |
    .      | the on-duty half joins|     .  .  .     | ten million desks, each   |
    .      | 0.9 h                 |     in step     | on its own slice; no town |
    .      |                       |     .  .  .     | consults another  (0.9 h) |
+13.0 h    +-----------+-----------+                 +-------------+-------------+
    .                  |                                           |
    .                  |          MLP outputs for layer k          |
+13.0 h                |<------ 327 kbit ~ 0.9 h of keying --------|
    .                  |                                           |
+13.9 h    +-----------+-----------+                               |
    .      | residual add + norm   |                               |
    .      | file the layer record |                               |
    .      | (negligible)          |                               |
    .      +-----------+-----------+                               |
    .                  |                                           |
    v                  v                                           v
             hidden state to layer                       towns sit idle until
             k+1: back to the top                      the next dispatch keys in


-------------------------------------------------------------------------------------
  THE BILL
-------------------------------------------------------------------------------------

  one layer     9.4 + 1.8 + 0.9 + 0.9 + 0.9   =   13.9 hours
  one token     13.95 h  x  120 layers        =   69.7 days
  the split     74% labour / 26% communication

  the capital keys and computes around the clock: two 12-hour shifts, half a
  million desks always lit. the towns need no relief -- each works 0.9 h in
  every 13.9, and the wire itself schedules their rest.

  every communication hour is serialization -- a fist tapping 327,000 bits
  onto the wire at 100 per second. propagation never shows up on the bill:
  the light-lag budget for the whole token is about a third of a second.

=====================================================================================

Abiogenis is a theorised process whereby nonliving matter develops into prototypical forms of living matter: simple self-replicating structures, RNA, proto-cells. I find this transition from chemistry to biology very interesting, because:

• It could explain the origins of life on Earth (and elsewhere)
• It should be possible to simulate without resorting to extremely simplified models, like rigid body physics for animals.
• The molecular/cellular scale can have an otherworldly aesthetic, which may work with the generative music part of the project.

What am I planning to build?

Here are the rough ideas as they stand: I want to build some web-based software that allows users to navigate space and time in a primordial soup. Time may be folded into space, and then the four dimensions (instead of the usual three) projected onto two. Instead of exerting agency, the viewer will be a passive observer. Generative music, the sophistication of which follows that of the simulated molecules, will be a big part of the viewer’s experience.

I plan to use WebGL and WebAssembly in a relatively low-level manner to handle potentially complex 3D scenes and heavy computation for the state. I’ll probably use Rust, as this is the only low-level language I’ve built anything with. Rust as a technical choice may fall over because I also intend to use as much AI tooling as possible. An older and simpler language like C is likely easier on LLMs and to have greater representation in the training data. I’ll adapt to the constraints of the tools. I’ll mainly rely on AI to augment my basic mathematical knowledge and utilize my experience in building software to ensure that the code is structured sanely. I'll likely write the music-related code in JavaScript and use something like SuperSonic as a synthesis engine; I'm imagining a few subtractive voices and lots of reverb.

While I could have chosen a less ambitious project to test AI coding tools, I feel that enough of my time is spent being pragmatic in my professional life. I don’t want to use my limited spare time to create a React app, Django HTTP API, or some Go microservices.

Why?

I haven’t read much philosophy since attempting a journal article on AI and the machinic unconscious over six years ago. I’ve been busy and have only read humanities books that strongly piqued my interest. One of these was a review of consciousness in recent analytical philosophy. I found the clear communication and modest claims of analytical philosophy refreshing, especially after doing two arts degrees where continental thought is far more popular (with notable exceptions). At worst, continental and continental-inspired writing is a sequence of complex sentences telling the reader how a constellation of different abstract concepts relate to each-other with no definitions or reference to facts. However, there are trade-offs: analytical philosophy can be dull. Much of the book could be summed up as follows: The hard problem of consciousness is indeed hard. There is overwhelming evidence that mental states correlate with brain states; we can’t agree on the details. Let’s find a palatable way of representing the situation that best fits our everyday experience of embodied rational agency. Here is a menagerie of -isms and some thought experiments.

If I wanted satisfaction, I should have read a book about a problem that can be solved. This brings me to abiogenesis. While no one has produced biology from non-living chemicals in a lab, there are a lot of models and theories for how it might work, and more on how primitive life works today. Attempting to make a computer simulation of how consciousness functions in relation to brain activity would be impossible. Where would you start? Large language models have passed the Turing test, but like all machine learning models, we have no reason to believe they’re any more conscious than a wheel of Camembert. We could set about tracing information as it flows through systems that populate a person’s mind; it might be interesting social science, but it wouldn’t address the hard problem of consciousness. Chemical and biological processes are more compatible than physical and mental substances, properties, whatever.

The final thing I’d like to share is a passage from a book that hit the sweet spot between the analytical and continental: Manuel de Landa’s A Thousand Years of Nonlinear History. He adapts and applies some of the most notoriously impenetrable continental ideas from Deleuze and Guattari in a concrete, historically grounded way. The book talks about the material flows that drive history through geology, biology, and language. I remembered a particular passage when thinking about abiogenesis:

[…] positive feedback links between these flows began to form closed-circuits: antimarket money flowed into mining regions and intensified coal production and iron extraction, which triggered a flow of mechanical energy (steam), which in turn triggered a flow of cotton textiles, which created the flow of profits that financed further experimentation with coal, iron and steam technology. These loops of triggers and flows were behind the explosive urban growth in England between 1750 and 1850. […] And precisely these autocatalytic loops were what kept this self-organised structure going.”

Autocatalysis is a likely step in the path from non-living to living matter. I find the idea that this kind of process also emerges at the macro level quite inspiring.

• Writers are at the mercy of the business, which can start charging for things and generally enshitifiying the platform at any time. They could paywall writers' content, like Medium does.
• My blog was associated with the general reputation of content on the platform, which wasn't always favourable.
• I don't only want to write about software engineering, and that is the focus of the platform.

My reasons for choosing a self-hosted WriteFreely are essentially the inverse of the above points, with a couple more:

• Writefreely has an ActivityPub integration, so my blog can be a true citizen of the Fediverse.
• WriteFreely is very simple. It's a Go monolith that can (and in the case of this site, does) run with a SQLite database. It uses Markdown, so no fancy text-editing widgets.

How did I do it?

Now that I've outlined why, I can move on to the unashamedly geeky part of this post. My main objectives were to run Writefreely in a way that was both simple and cheap.

Simplicity

I got a lot of simplicity for free with this WriteFreely Docker image, which neatly encapsulates the initial configuration of WriteFreely as well as data migrations. The image doesn't leverage Writefreely's built-in automatic HTTPS. Luckily, another Go-based project, Caddy, does this, on top of being a solid reverse proxy.

Those of you who have used the likes of Apache or NGINX, but not Caddy, please take a moment to admire the two lines of configuration necessary to reverse proxy this blog:

simoncrowe.blog

reverse_proxy localhost:8080

Yes, this is all that's required to serve this blog and automatically provision TLS certificates using Let's Encrypt!

Frugality

The localhost origin in my Cadddyfile above isn't typical of a Docker-compose setup. It's a result of my trying to save money by not renting a public IPv4 address from Hetzner and only using a free IPv6 address. Caddy needed an internet-routable IPv6 address to get responses from Let's Encrypt's servers, and using the “host” network mode was the simplest way to achieve this.

The laptop I'm typing this on doesn't have an IPv6 address, so I couldn't SSH into the server, even if I wanted to. To get around this for HTTPS traffic, I used Cloudflare as a DNS registry and proxy. This means that simoncrowe.blog resolves to some of CloudFlare's v4 IPs. CloudFlare handles everything between the Hetzner IPv6 origin and its own dual-stack infrastructure, at no cost.

Trade-off time: My insistence on not paying the tiny IPv4 address fee has probably increased the complexity of this. The no SSH constraint is what motivated me to write a Terraform/OpenTofu module. Using the Hetzner web shell to configure even a simple setup like this would have been a miserable experience compared to SSH from the comfort of my laptop's terminal emulator. Because I've been lazy and put the database in the same machine as the HTTP server, I've already consigned the server to a long existence as a pet. Immutable Infrastructure is not happening here, so doing everything via the Hetzner web console and SSH would have been reasonable.

On the other hand, maybe my code will help someone else run their own WriteFreely. Here's the repo.

Cheap compute with a cloud API! What else can Hetzner do?

Since I managed to throw something functional together in a weekend, I'm wondering what one could do with Hetzner and IaC tooling like OpenTofu, given some time.

While I haven't explored their full networking and compute capabilities, the impression I got is that they'd be fine to run an early stage European startup's backend (with some caveats). Anything approaching a scale-up with global ambitions would be better off with a major public cloud provider. The main reason I say this is that they only have data centres in Germany, Finland, the US and Singapore (the latter two being rack-space in 3rd party data centres).

To me, Hetzner feels somewhere between a typical shared LAMP stack web hosting provider one might use for a Joomla/WordPress site and a mail server — and rudimentary AWS (mainly ec2, some s3 and recently a bit of route53). When creating VMs manually on Hetzner, you can install one piece of common software. Like the LAMP hosting, options include WordPress, but also more advanced things like Docker and Prometheus/Grafana. Unlike typical web hosting, you can provision infrastructure using an API, and you get root access to your servers. Rather quaintly, when a server spins up, you get an email with the default root password (luckily, sshd isn't running out of the box).

If I were a frugal European startup founder, the only thing that would stop me from choosing Hetzner is the lack of managed databases. The VMs could easily run stateless workloads where new software versions are rolled out smoothly using OpenTofu lifecycle policies. While one could run a database on such a VM, one would need to be very careful about backups and learn database administration. A tolerable middle ground might be running production databases using AWS RDS/Aurora in AWS regions geographically close to Hetzner locations; sure, there would be some extra latency, but it might be manageable.

I'll keep an eye on Hetzner. I'm impressed with how straightforward everything is with them. At the top of my wish list would be managed stateful services like Postgres and Kubernetes, a container registry, and guarantees around availability zones (high availability in general). Serverless versions of every imaginable thing, I can live without.