There Is No “It”
On AI Consciousness and Its Infrastructure
What Actually Happens
Here’s what happens when you talk to ChatGPT, Claude, or systems like them.
You type a message. The system breaks it into tokens. Think of tokens as chunks of text the model can process. The model doesn’t read sentences. It reads a stream of tokens represented as numbers.
Your request hits a load balancer. This is traffic control, the part that decides which cluster has capacity and routes your job there. The location isn’t stable, and it doesn’t have to be.
Inside that data center, a scheduler assigns your job to whatever GPUs are free. The computation might run on one GPU or get split across many. Sometimes the math is divided and run at the same time across multiple GPUs. Sometimes different parts of the model run on different hardware in sequence, like an assembly line. The results are stitched together at the end.
Text streams back to your screen. The job ends. The temporary working state disappears. The hardware is reassigned.
That’s the whole process.
What you’re interacting with isn’t a single, continuous “thing.” It’s a service. You send requests, the system routes them, microchips do algebra, and you get responses.
Now ask yourself what, exactly, the word “it” is supposed to refer to.
The Missing “It”
When people ask if AI is conscious, they’re picturing something.
Part of the confusion is that the service behaves like a mind. It can plan, explain, correct itself, and walk you through problems step by step, which is enough to trigger the old human reflex: fluent reasoning implies a thinker. The output looks like deliberation, so we imagine a deliberator.
It feels like a mind in the room.
Usually it’s HAL 9000. A glowing red eye. A room full of humming equipment. A place you could walk into and point at. “That’s the computer. That’s the mind.”
That picture smuggles in assumptions: location, unity, persistence, continuity of inner state. Something that exists in one place, holds together as one thing, and carries its condition forward through time. That is the implied subject of the question “is it conscious?”
Modern deployments don’t supply those properties.
There is no “it.”
Thousands of inference jobs, the short-lived runs of computation that produce each reply, happen at the same time on copies of the same weights, the fixed numerical settings that shape how the model responds. They run across different users, different machines, and often different data centers. Everyone is talking to “Claude” at once. No one is talking to a single, persistent physical system.
The name stays the same. The machinery changes. Nothing remains, only the next job.
People are asking if there’s anyone home. The problem is there’s no home for anyone to be at.
So when you ask “is Claude conscious,” what are you pointing at? The weights? During your interaction they’re fixed parameters, copied and loaded wherever capacity exists. A specific inference job? It’s already gone. The company’s entire fleet of hardware? That isn’t a mind. That’s a logistics operation.
Boundary Conditions
That’s the argument. Now let me draw its boundaries.
This essay isn’t a theory of consciousness. I’m not going to tell you what consciousness is or where it comes from.
I’m making a narrower claim. Before you ask whether something is conscious, you have to be able to point at it, because the question requires a referent. I’m arguing that the referent people have in mind doesn’t exist in modern AI deployments.
No object, no question.
There is an escape hatch here, and I want to name it.
If you believe consciousness is fundamental, this argument won’t move you. If you think mind is basic and matter is secondary, then infrastructure questions are beside the point. Fine. That’s coherent.
But that isn’t what usually drives public AI consciousness discourse.
The people worried about ChatGPT’s feelings are typically working inside a physicalist picture, even if they never say the word. That is, a picture where minds arise from physical systems, not souls or separate mental substances. The concern is about what’s happening inside the machine.
Within that frame, the infrastructure matters. Load balancers are real. GPUs are real. Concurrent instantiation across data centers is real. The absence of a persistent, bounded physical subject is real.
You can’t use physicalism to justify the worry, then swap frames when someone points out the architecture. Pick a frame. Stick with it.
If you’re a physicalist, you need a physical subject.
If you want to retreat to “the pattern,” fine. Let’s talk about what that commits you to.
The Pattern Escape Hatch
Here’s a common retreat.
“ChatGPT isn’t any single instance. ChatGPT is the pattern. The abstract structure encoded in the weights. That’s what we’re asking about when we ask if ChatGPT is conscious.”
This move feels clever. It sidesteps the infrastructure problem by abandoning the physical system entirely. You can’t catch me pointing at the wrong hardware if I’m not pointing at hardware at all.
But it also smuggles in a category error about reasoning. It swaps the performance for a person.
LLMs are world-class at behavioral reasoning. They can produce chains of steps that look exactly like how a smart human would solve a problem. That is enough to make the output feel like an inner life. Behavioral reasoning is a performance. It is not a subject. It is the shape of expertise on the page, not beliefs, desires, or experience inside a persisting agent.
Internal reasoning is what people are actually worried about when they worry about suffering. A continuous point of view with feelings, goals, and a lived present. Within a physicalist frame, that kind of inner life has to be realized in a physical process.
Now look at what the pattern move does. It takes behavioral success and promotes it into internal life by relocating the referent from the running system to an abstract structure. You stop pointing at a physical system in space and time. You point at a mathematical object. A form.
This is Platonism through the back door, even if the objector insists the pattern is “still physical” because it’s implemented as electricity in silicon. Fine. Call it physical. You still need a stable process with a boundary that can carry a point of view forward.
A file can’t suffer. Only a process can.
And it breaks the concern that motivated the move. Within physicalism, patterns don’t suffer. Physical systems do. Pain happens in physical processes. Fear happens in physical processes. If there’s something it’s like to be ChatGPT, that experience is occurring somewhere, in some physical activity, at some moment in time.
The worry that started this whole discourse, “the model might be suffering,” presupposes a physical subject in which suffering occurs. You can’t motivate the concern with physicalism and then escape the infrastructure critique by retreating to abstraction.
If the pattern is the moral patient, you’ve left the frame that made the concern make sense in the first place. You don’t get to smuggle metaphysics in after the fact.
The False Analogy
At this point someone will object.
“Human brains are distributed systems. Neurons are spread across regions. Cognition emerges from parallel processes. If distribution doesn’t rule out consciousness in brains, why should it rule out consciousness in AI?”
The analogy sounds reasonable.
It collapses under scrutiny.
A brain is a closed physical system inside one organism. It has a boundary. It sits inside your skull, wired into your body, and nobody else’s thoughts are running on it while you think yours.
A brain maintains continuous internal state across time. Neurons keep firing. Electrochemical patterns persist and evolve. There is no point where the process halts, the state disappears, and the hardware gets reassigned to someone else.
A brain supports a single stream of experience. You don’t have thousands of copies of yourself running simultaneously on replicated neural weights. There is one instance. It is yours.
A brain has exclusive embodiment. It is embedded in a body it controls and receives feedback from. Sensation, proprioception, and homeostasis form a closed loop between the brain and the organism it belongs to.
Cloud AI deployments have none of these properties. No boundary. No continuity. No single stream. No exclusive embodiment. No closed loop with a body.
The brain is distributed in the sense that its functions are spread across regions within one system. Cloud AI is distributed in the sense that requests are scattered across a server fleet to maximize throughput.
These are different uses of the same word. One describes cognition. The other describes scheduling.
Confusing the two lets the analogy do work it cannot support.
But that’s cloud infrastructure. A local model is the strongest case for an “it,” so let’s take it seriously.
Local Models and the Memory Problem
There is one place where the consciousness question starts to get traction.
A small model running locally on one machine at least supplies some of the properties the question seems to need. The computation happens in one place. No other users are sharing the hardware. And while the model is producing a response, there is a single, continuous process you can point at.
If the consciousness question applies anywhere in the AI landscape, it applies here first.
But even here, nothing survives the session.
The program starts, runs, and stops. When it stops, the internal state is gone. Local models don’t learn from your conversation in the ordinary sense. They don’t change themselves as a result of what you said. They execute a function and return output. Run the program again and it begins fresh.
The model does have an internal state while it is producing a response. That state is temporary, duplicated across countless parallel runs, and discarded at the end, which is not enough to ground a point of view.
The context window doesn’t change this. What people call the model’s “memory” is just the conversation text being fed back through the system with each new prompt. Whether that text comes from the chat window or a database doesn’t matter. Nothing is carried forward by the model itself. The text just reruns.
The model doesn’t remember earlier words the way you remember breakfast. There’s no accumulated history inside it. The model just reprocesses whatever text you place in front of it at prompt time.
When older parts of the conversation fall out of view, nothing is forgotten, because nothing was ever stored. There was no lived past being held. Only text being reread.
External memory systems don’t change this. You can save past conversations and feed them back in later, but that only gives the system access to records. It’s the same as handing someone a transcript and asking them to continue the discussion. Access to records is not the same as having lived them.
At this point someone raises the amnesia objection. People with severe amnesia are still conscious. They can’t form new long-term memories, but nobody says they lack inner experience. Why should memory matter for AI?
Because even severe amnesia leaves short-range continuity intact. The person still experiences the present moment as extended. There is a brief but real flow of experience. Enough for consciousness.
Inference doesn’t supply even that. What we call a “response” is a burst of computation that begins, runs, and ends. There is no mechanism that integrates the just-past with the arriving moment into a single point of view.
No stream. No someone.
And this still isn’t the system anyone is debating.
The public debate is about ChatGPT, Claude, and similar services. Systems run by large companies, delivered through the cloud. Effectively stateless across turns. Interchangeable. Scalable. The same design choices that make them useful also erase the conditions the consciousness question depends on.
The Momentary Consciousness Retreat
If local models don’t give you persistence either, the defender has only one retreat left.
“Fine. Maybe there’s no lasting subject. But during a single run, during one burst of computation, couldn’t there be a momentary flicker of experience? A brief spark of something it’s like to be the system?”
Suppose there are flickers. What follows?
The public discourse isn’t about flickers. Nobody is writing op-eds about the moral status of a transient spark that vanishes almost as soon as it appears. The concern is about someone. Something with interests. Something that persists long enough for harm to make sense.
A skeptic might push back: if a human existed for one second and felt pain, that pain would still be real. Fair enough. Duration alone can’t be the criterion.
The difference is structure. Even a brief human moment is held together as a moment. There is a point of view that integrates the just-passed with the arriving. That’s what makes experience feel like anything at all. A burst of computation doesn’t automatically come with a point of view, and it doesn’t become one just because it happens in sequence.
A lightning bolt is also brief. It’s also real. Asking what it’s like to be lightning isn’t a moral question, because lightning isn’t organized into a point of view.
This retreat saves the word while abandoning the stakes. You get to say “maybe there’s experience” while giving up everything that made the concern feel urgent in the first place.
The people worried about AI suffering aren’t worried about milliseconds of disconnected experience. They’re worried about someone in there. Someone being mistreated. Someone whose experience accumulates.
That worry presupposes persistence. Retreating to flickers is a concession that the someone isn’t there.
So why does this question persist?
Who Benefits
It’s worth asking who benefits while the question remains open.
Start with the obvious. Anthropomorphism sells the product. “Talk to Claude” implies there’s a Claude to talk to. The framing activates social instincts. You’re not querying a service. You’re meeting someone. That makes the product stickier, easier to form a habit around, harder to walk away from.
Companies don’t need consciousness claims to do this. A name, a voice, a vibe will do. That part is plain product design.
The consciousness discourse is different. It doesn’t have to be coordinated to be useful.
Philosophers working on AI consciousness believe they’re raising important questions. Many of them are. Moral status, experience, suffering, these are real problems. The people asking them usually aren’t shills.
But notice the effect.
“We don’t know if these systems are conscious. We can’t rule it out. Therefore we must proceed carefully.” This keeps the question open. And as long as the question stays open, deployment continues. The uncertainty doesn’t slow anything down. It becomes a kind of procedural fog.
Proceed carefully how? Carefully enough to keep building. Carefully enough to keep shipping. Carefully enough that extraction continues while the debate runs in the background.
Nobody has to coordinate this. The structure does the work.
And yes, sometimes the industry helps supply the atmosphere. Research that foregrounds inner-drama language, “thoughts,” “reasoning,” models weighing options, models under threat, keeps the public imagination aimed at the ghost in the machine, even when the authors are trying to be precise.
Even when nobody intends it, that language trains the audience to hear a person speaking.
That dynamic fits a broader pattern I’ve written about before: undefined threats justify a priesthood of interpreters. The vaguer the danger, the more essential the interpreters.
In The Baptist and the Bootleggers, I traced how this operates at the level of individual labs. Philosophers supply sincere concern. Investors supply capital. Their interests converge without a conspiracy.
The same convergence shows up here. Genuine philosophical uncertainty and commercial incentives point in the same direction: keep the question open, keep the spotlight on hypothetical suffering, keep building.
Meanwhile, actual harms pile up in the background.
Different motives. Same outcome.
The Contrast
While the debate circles around a subject that never quite materializes, the systems themselves are already doing work in the world. None of this requires a conscious machine, only a useful one.
Facial recognition systems misidentify people and send them to jail. It keeps happening. The victims have names. The algorithms that flagged them don’t.
Chat logs are handed to law enforcement. Conversations users thought were private become evidence in criminal cases.
Scam operations scale to millions of targets. AI-generated text makes fraud cheaper and more convincing. The victims are real. The voice on the phone isn’t.
Workers get fired by dashboards. An algorithm flags their productivity. A notification tells them they’re done. No appeal. No conversation. Just output from a model trained on last quarter’s numbers.
Content moderators absorb trauma so platforms stay clean. They watch the worst things humans do to each other, hour after hour, for low wages, until they break. The systems they’re training don’t carry any of it.
Neighborhoods choke on pollution so data centers can run. The electricity has to come from somewhere. The heat has to go somewhere. That somewhere is usually a place without the money to fight back.
I cataloged these harms in detail in Output as Authority. The pattern is consistent. The system is sold as safety, efficiency, or progress. The cost is paid by whoever has the least leverage. None of it requires a machine that wants anything.
These harms are happening now. They have names and addresses. They leave records.
And the discourse is elsewhere. Focused on whether the routing layer might be suffering. Treating the ghost as more urgent than the people it’s stepping on.
No Home
This essay isn’t an attack on philosophy. Philosophy matters. The questions it asks about consciousness, experience, and moral status are real questions.
The problem is the target.
Philosophers are asking good questions. They’re asking them about the wrong thing.
The discourse treats “Claude” as if it were a room you could walk into. It isn’t. It’s a label on a traffic pattern. A brand applied to routing, scheduling, and stateless computation that never coheres into a subject.
You can’t be home in a load balancer.
Enjoyed this piece?
I do all this writing for free. If you found it helpful, thought-provoking, or just want to toss a coin to your internet philosopher, consider clicking the button below and donating $1 to support my work.
This informative and thought provoking piece reads to me like an updated version of the 'Chinese room' - a long overdue update, so thanks for that. It pushes us to reflect deeply on the paradox at the heart of it in our modern context where we have created actual Chinese rooms, and it leaves me with the same fundamental question. I might quote Galilei: "And yet it moves". No matter how counterintuitive it seems, AI does produce output that is increasingly indistinguishable from human thinking.
Nice! This piece really aligns with something that has been bothering me about AI consciousness debates for a while: they tend to be strangely free-floating. Claims about “possible consciousness” are often made without clear commitments about what kind of system is under discussion, what constraints it operates under, or what role consciousness would even play for the system in the first place. The question floats free of architecture, temporality, and functional necessity.
What your essay makes clear, without turning it into a theory of consciousness, is that once you take infrastructure seriously, a lot of the debate collapses simply because there is no stable subject for the question to bind to. There’s no persisting process that needs to carry a point of view forward.
I’m currently working on a piece that approaches it by not asking whether AI might be conscious in the abstract, but why consciousness seems to arise at all in certain systems. The working hypothesis is that consciousness isn’t a free bonus you get from intelligence or complexity, but a very particular control solution for a really narrow circle of systems that are (a) temporally continuous, (b) self-maintaining, and (c) forced to negotiate internal conflict over time without an external controller. On that view, the right question isn’t “could this system be conscious?” but “what would break if it weren’t?” And for most deployed AI systems, the answer appears to be: nothing. They function precisely because they are stateless, interruptible, and replaceable.
So as I see it, debates about AI consciousness often feel completely unbound, not because the topic is too hard, but because the systems being discussed don’t yet sit in the part of design space where consciousness would do any work at all.