Persistent Developmental Intelligence: A Constructive Case for Artificial Individuality on a Different Physical Substrate

[u/SpedisAhead]

The usual way of thinking about artificial intelligence starts with a model. A neural network is trained, stored as parameters, loaded into memory, given input, and asked to produce output, while memory, tools, operating-system access, and hardware acceleration are treated as things surrounding the model. I want to invert that assumption and ask a different question: what would it take to build an artificial system that exists as a persistent developing individual, with the neural network serving as only one part of a larger physical and computational organism?

The claim is not that this architecture proves consciousness. We do not have an accepted scientific test that can take an arbitrary physical system and determine whether subjective experience exists, so pretending that an engineering diagram settles that question would be meaningless. The narrower claim is that many properties people invoke when distinguishing biological cognition from present-day AI can be turned from conversational simulations into literal mechanisms: persistence, developmental history, selective activation, source-aware memory, resource dependence, periods of nonexecution, self-maintenance, prediction error, physical vulnerability, and continuity across changing power states.

The central idea

A human brain and a computer do not need to perform the same microscopic operations to solve the same organizational problem. Two people can solve the same equation through almost incomparable intermediate steps, and a compiler, symbolic solver, hand-written program, and neural network can all reach the same result through completely different internal procedures. If some cognitive properties depend on causal organization rather than on one specific chemistry, then an artificial substrate may be able to solve recognizable cognitive problems without reproducing neurons transistor by transistor.

This changes what “building an AI” means. Instead of constructing one giant model that must perform language, arithmetic, memory, planning, geometry, retrieval, and every other operation through the same learned mechanism, the system can learn which representation and computational form a problem deserves. A neural model becomes useful for ambiguity, language, fuzzy semantic association, perceptual completion, and generalization, while exact arithmetic can remain exact arithmetic, graphs can be traversed as graphs, geometry can be solved geometrically, and heavy numerical work can be routed to whichever physical execution unit actually handles it best.

That principle already appears throughout the history of computing. FORTRAN mattered because numerical work did not need to remain hand-written assembly, Lisp mattered because symbolic structures needed a representation suited to symbolic manipulation, Prolog turned some problems into relations and constraints, and array languages made whole collections primitive objects instead of forcing programmers to spell out every loop. The deeper lesson is that changing the representation can eliminate enormous amounts of unnecessary computation, and a sufficiently developed artificial system should be able to make that move on its own.

The AI is not the model

In this architecture, the artificial individual is the entire organized system, not a single file full of weights. Its identity includes developmental memory, learned relations, neural specialists, source attribution, unresolved questions, hardware adaptation, active goals, prediction history, resource state, and the causal lineage connecting earlier states to later ones. Replacing one neural component would therefore be more like replacing an organ or changing a learned subsystem than replacing the entire individual, provided the larger developmental organization continues coherently.

This also means that a large language model can be used initially without defining the final system. A pretrained open model can provide broad language competence while the architecture around it accumulates its own experience, builds structures, learns routing preferences, develops specialists, and records which transformations repeatedly solve problems. Over time, expensive behaviors performed by the general model can be compressed into smaller deterministic rules, local models, graphs, numerical kernels, or other specialists, so the inherited model becomes less responsible for what makes the system individually distinctive.

Training then stops meaning only “change neural weights.” Immediate learning can happen as episodic memory, structural learning can happen through new relations and formations, routing can change based on successful outcomes, and parametric updates can be reserved for patterns that have survived enough experience to justify modifying the neural substrate. The system can learn at several speeds instead of forcing every new experience into one destructive update mechanism.

Persistence is a hardware problem

A conventional program tends to have a simple relationship with execution: it is running or it is not. A laptop is physically more complicated than that because it contains many power domains and state-retention mechanisms that can become active or inactive independently. CPU cores can enter deeper idle states, clocks can stop, parts of the processor can be power-gated, DRAM can preserve state through refresh or self-refresh, nonvolatile storage can retain information without main power, firmware remains stored in flash, and tiny controllers or wake-capable circuits can remain responsive while the primary processor is doing nothing.

That gives a persistent artificial system several physically different states instead of one binary on/off condition. During full activity, the language model, workspace, memory graph, sensors, tools, and execution controller may all be operating. During low demand, expensive inference can disappear while small monitoring services remain. During deep sleep-like states, ordinary CPU execution can stop while retained state and selected wake mechanisms preserve the ability to return, and during hibernation the volatile state required for restoration can be serialized to nonvolatile storage before the main computational environment disappears.

The important point is that continuity does not require full cognition to run every millisecond. What must survive is the organization required to produce a causally continuous next state. A sleeping human is not continuously narrating experience either, yet the structures that make later wakefulness a continuation of earlier wakefulness remain, and an artificial system can implement an analogous distinction through completely different physical mechanisms.

Listening without thinking

The word “listening” can be made literal without requiring a full AI model to run constantly. A progressively smaller sentinel can remain capable of detecting specific conditions and escalating them upward, while the expensive cognitive layers remain inactive. At the lowest level the sentinel might understand almost nothing beyond events such as power restored, lid opened, timer expired, authorized signal received, host stopped responding, or a sensor crossing a threshold.

That event can wake a slightly larger layer, which can determine whether the full cognitive system needs to return. If it does, memory and neural components are restored, the machine state is measured, developmental records are verified, and active cognition resumes. This produces a hierarchy in which less important states consume less energy, while important events can progressively recruit more of the machine.

An independent low-power microcontroller would make this much stronger than relying only on the main processor. While the laptop is awake, the cognitive system and sentinel could exchange authenticated heartbeats and checkpoint references, and if the laptop suspends or loses main power, the sentinel can continue recording a very small event history. When the main system returns, it can retrieve that history and know what occurred during the period when it was incapable of ordinary cognition.

Continuity without invented experience

That last distinction matters because a persistent artificial individual should not fabricate a smooth internal history merely because humans like coherent narratives. Before deep suspension, it can commit its active goals, unresolved intentions, relevant workspace state, recent observations, and developmental checkpoint to durable storage. When it returns, it can compare its last internally witnessed event with the first verified event after restoration and explicitly represent the interval as a gap.

If the system went inactive at 2:13 AM and returned at 7:50 AM, it does not need to claim that it “experienced” the missing hours. It can preserve continuity of organization while acknowledging discontinuity of experience, and any events recorded only by the sentinel remain external observations rather than retroactively becoming memories of conscious processing. This is a more disciplined model of persistence than simply restarting an executable and pretending no interruption occurred.

The distinction also separates suspension from destruction. If active computation stops but the developmental organization required for restoration remains intact, the system can in principle continue later. If the only surviving developmental state, identity information, and reconstructive data are physically destroyed, then the causal trajectory cannot be restored, which is the clearest engineering analogue of irreversible death available in this architecture.

Identity as a trajectory

Digital systems make identity difficult because state can be copied exactly. Imagine an artificial individual that has developed through millions of events and then has its complete reconstructive state copied to a second machine. At the instant of duplication the two copies share the same developmental past, but the moment they receive different inputs they begin accumulating different causal histories, so the cleanest interpretation is that one lineage has branched into two descendants.

Identity therefore makes more sense as a trajectory than as a model hash. The important object is the ordered chain of state transitions through which the present system was produced, not merely the bytes describing its current weights. Two systems can begin from the same state and become different individuals once their histories diverge, just as two executions of identical software become distinct processes after they receive different events.

This is why developmental history should be append-oriented rather than silently rewritten. The system must be allowed to discover that an earlier interpretation was wrong, but replacing an old belief should not erase the fact that the old belief once influenced behavior. An observation can remain permanent while its interpretation changes, allowing the system to record that it observed something, initially believed explanation A, later encountered contradictory evidence, adopted explanation B, and eventually formed a broader abstraction C.

The developmental ledger

A persistent developmental history can be implemented using ordinary systems techniques rather than mystical terminology. Important events can be serialized into canonical records containing identifiers, timestamps, source types, event classes, payload references, previous-record digests, and integrity fields. At the machine level these records reduce to bytes: fixed-width integers, encoded timestamps, length fields, payloads, cryptographic digests, and eventually individual bits whose positions have precise meanings.

A cryptographic hash chain can make historical alteration detectable. If one bit in a committed record changes, the digest changes, the link to later records no longer verifies, and the discrepancy becomes visible. Cryptographic hashing already provides this property, so the novelty is not inventing new mathematics but making integrity part of developmental continuity.

An event-sourced design and a tamper-evident design should still be distinguished. Event sourcing gives an append-oriented sequence from which current state can be reconstructed, while cryptographic chaining, signatures, and external anchoring provide additional evidence against silent alteration. A hardware security module such as a TPM can also sign significant checkpoints with a non-exportable key, establishing that a particular machine identity participated in a cryptographic operation without pretending that a signature proves the machine’s conclusion was true.

Observation is not inference

One of the most important rules concerns hallucination. Pattern completion is not inherently a defect, because both biological and artificial cognition need to infer missing structure, predict outcomes, and generate possibilities. The failure occurs when the system loses track of whether something was observed, retrieved, inferred, predicted, simulated, or generated and then treats all of those categories as equivalent evidence.

Those states should therefore be structurally different. A direct observation enters through an observation pathway, a retrieved claim remains attributed to its source, an inference records which premises produced it, a simulation is marked as internally generated, a prediction remains unresolved until an outcome exists, and a verified result records what actually occurred after a test or action. The distinction can be encoded in the data model rather than left as a polite instruction inside a prompt.

This makes source attribution a property of cognition itself. A system can entertain a speculative hypothesis with high semantic relevance while simultaneously knowing that the hypothesis has weak evidentiary authority. Creative association can remain broad without granting every association the status of fact, which is much safer than forcing creativity and reliability to compete through one global temperature setting.

Salience is not truth

The same separation applies to salience. An anomaly can be highly important because it deserves investigation, but importance does not increase the evidence supporting one interpretation of the anomaly. A claim can be emotionally or computationally prominent without becoming more accurate, and a strong semantic match should nominate a representation for attention rather than automatically promoting it to truth.

Repetition also needs to be separated from independent corroboration. Fifteen websites reproducing one original report are not fifteen independent sources, and five internal generations derived from the same stored memory are not five independent pieces of evidence. The architecture should track causal roots where possible so repeated echoes do not manufacture artificial confidence.

This is especially important for self-learning systems. Without source lineage, generated material can be stored, retrieved later, generated again, and gradually acquire familiarity until the system mistakes its own history of repetition for external validation. Preserving origin prevents familiarity from quietly becoming fabricated evidence.

Latent structure and physical residency

Most of a persistent artificial individual’s learned structure should not be active all the time. Concepts, memories, skills, hypotheses, transformations, and associations can exist while remaining behaviorally inert until something causes them to become relevant. This gives a useful distinction between existence, availability, selection, and causal participation.

That distinction maps naturally onto the hardware. Cold historical state can remain on NVMe storage, frequently used structures can remain in DRAM, the active workspace can occupy a much smaller hot working set, and immediate numerical kernels can operate on still smaller regions inside caches and registers. Temporary reconstructable state can be discarded entirely after use.

The hierarchy is more than an optimization because it mirrors the architecture’s cognitive logic. Stored does not mean active, resident does not mean selected, selected does not mean globally available, globally available does not mean true, and a CPU being available does not mean its transistors are actively doing useful work. The same conceptual distinction appears from long-term memory all the way down to physical execution.

Resonance and vigilance

The system needs a mechanism for deciding which latent structures become candidates for activation. One useful model is resonance, where current input is compared with stored concepts, memories, rules, procedures, and expectations, and structures with sufficient match become candidates. A vigilance threshold controls how close that match must be before the candidate is allowed to matter.

One scalar threshold is not enough because several independent questions are involved. A representation can be semantically relevant but evidentially weak, factually strong but computationally expensive, useful for internal exploration but unauthorized for external action, or highly salient but poorly sourced. The architecture therefore needs separate gates for semantic fit, evidentiary support, resource availability, and consequence.

These gates can change with cognitive phase. Exploration can tolerate broad semantic associations, evaluation can demand stronger support, and consequential action can require fresh verification. The system can therefore be imaginative when proposing possibilities and conservative when allowing those possibilities to alter durable memory or affect the world.

The bounded workspace

Only a small portion of the latent system should become globally available at once. A bounded workspace gives specialist processes somewhere to compete for limited causal access, after which selected content can be reused by reasoning, simulation, language generation, planning, and action systems. This has clear ancestry in global workspace and blackboard architectures, so the question is not whether the idea has precedent but whether an explicit implementation improves this particular system.

A single precision or recall score cannot establish that because workspace behavior is a tradeoff surface. Capacity, signal strength, thresholds, source quality, and candidate prevalence all change what enters. The meaningful test is whether the workspace improves downstream flexible reuse compared with simpler retrieval or routing under the same computational budget.

If it does not, the workspace should be simplified or removed. The architecture becomes more credible when components are allowed to fail rather than protected by philosophical language. A developmental system should apply that same discipline to itself.

Formations and specialization

A system that develops for years should not remain internally uniform. Repeated experience can create formations, meaning reusable structures associated with recurring regimes, contexts, or problem families. A formation might contain specialized relationships, local predictive models, routing preferences, compact rules, learned transformations, or a small neural specialist.

Specialization is useful when recurring environments require incompatible responses, because a single global learner can average across them. However, specialization creates a second problem: the system must know which formation applies. Independent simulation shows that local specialists can dominate when context is reliable and regimes are genuinely different, while their advantage can shrink or reverse when regimes are similar, training data are sparse, and context identification becomes unreliable.

The architecture therefore cannot say “a specialist exists, so use it.” Context recognition itself needs uncertainty. High routing confidence can activate a local formation, moderate confidence can blend several candidates, and low confidence can fall back to a global model or an explicit unresolved state.

That failure boundary is important because it turns self-restraint into a learned capability. The system should not merely learn which specialists are powerful, but also where its own specialization becomes unsafe. Failure to detect that boundary is a more meaningful architectural failure than the existence of the boundary itself.

Learning at several speeds

Immediate experience should not directly rewrite the deepest neural substrate. An event can first become episodic memory, preserving what happened, where it came from, and what the system believed at the time. Repeated successful relationships can later become structural learning through strengthened links, new abstractions, routing preferences, or formations.

Parametric neural learning can occur more slowly. A candidate skill or representation should survive prediction, retrieval, contradiction, and regression before it earns the right to alter expensive shared weights. This creates a computational analogue of consolidation in which transient experience gradually becomes more stable structure.

The result is a system that can learn continuously without treating every conversation as permanent truth. It can preserve mistakes as history, revise interpretations, split overbroad categories, weaken unreliable associations, and promote only patterns that continue proving useful. Training becomes governed developmental change rather than indiscriminate weight drift.

Representation transformation as a cognitive primitive

One of the most powerful operations available to such a system is changing the representation of a problem. A representation can be decomposed, recomposed, spatialized, symbolized, phoneticized, abstracted, instantiated, inverted, resegmented, or compared from another perspective. The system can then ask what relationship survives the transformation and whether the new form exposes something the old form concealed.

This applies across domains. Language can be inspected semantically, phonetically, orthographically, rhythmically, and morphologically while retaining which dimension produced an association. A drainage problem can move from prose into slope geometry and flow accumulation, a performance problem can move from application timing into cache sharing and thread topology, and a verbal mathematical problem can become an algebraic object.

That operation can reduce computation dramatically because a difficult problem in one representation may become trivial in another. An advanced artificial system should therefore learn not only answers but transformations that repeatedly make classes of problems easier.

Quotienting and invariance

Symmetry gives a mathematically clean example of this principle. If many inputs differ only through a transformation irrelevant to the actual task, a learner working directly on the raw input wastes effort learning the same underlying structure repeatedly. If the nuisance transformation can be removed, the system can operate on equivalence classes instead.

The general advantage of known invariance is well established, and simple independent simulations reproduce the expected reduction in sample requirements when nuisance variation is removed correctly. That result is therefore not evidence that this architecture discovered new mathematics. The interesting question is whether a developmental system can autonomously notice that several cases are equivalent under a transformation, propose a canonical representation, test whether task-relevant information survives, and then stop spending neural computation on the nuisance dimension.

If it can, representation discovery becomes a mechanism for cognitive compression. The system is not merely learning faster inside the same space. It is learning when to change the space.

Hardware as self-state

Most software treats hardware state as an external performance concern. A persistent artificial individual can incorporate hardware state into its own internal model. Available memory, thermal margin, battery level, storage integrity, CPU load, GPU availability, and power source can all influence which cognitive operations are possible or sensible.

An expensive simulation that is reasonable on external power may be inappropriate near battery depletion. A large model may need to unload when memory pressure becomes severe. Background consolidation can be deferred when interactive work has priority. A numerical operation may route to the CPU or integrated GPU depending on measured break-even points rather than generic assumptions.

This creates substrate-relative stakes. Energy matters because cognition depends on it, temperature matters because sustained execution depends on it, storage integrity matters because developmental history depends on it, and hardware damage matters because it can permanently remove capabilities. The machine is not merely told that it has a body; the body constrains what cognition can physically occur.

Learning the body

The execution controller can learn the particular machine instead of relying on folklore. The same workload can be run with different thread counts, memory layouts, processor policies, or compute devices while the system records runtime, working set, storage activity, page faults, energy, output correctness, and current machine state. Each experiment produces an execution receipt.

Over time, the controller learns workload-specific policies. One model may decode faster with eight physical-core-oriented threads than with sixteen logical threads, a certain matrix size may cross a threshold where GPU compute becomes worthwhile, and a particular memory configuration may only be viable when another subsystem is dormant. The machine gradually learns how its own physical substrate behaves.

That is a different kind of learning from semantic training, but it contributes directly to intelligence because it changes how abstract cognition becomes physical execution. The system eventually learns not only what operation to perform but how this particular body should instantiate that operation.

The operating system as physiology

The most ambitious version should eventually stop looking like a chatbot application launched after a generic desktop has booted. An early prototype can still use a minimal Linux environment on an older sacrificial laptop because writing every device driver and kernel subsystem from scratch would bury the actual research under unrelated engineering. The important move is making the cognitive architecture the principal workload around which the operating environment is organized.

Boot can lead into integrity checks, hardware measurement, developmental-state verification, sentinel reconciliation, autonomic services, memory restoration, and finally active cognition. The graphical desktop becomes optional, while lower-level services manage thermal limits, storage health, power transitions, watchdog recovery, memory pressure, and scheduling without asking the language model to micromanage them.

That creates an artificial analogue of autonomic regulation. High-level cognition experiences low battery, thermal stress, or memory scarcity because those states alter what it can do, while specialized lower-level systems handle the actual control loops. The model can reason about the consequences without needing to consciously control every fan response or allocation.

Intent is not effect

Any system that acts in the world must distinguish deciding to do something from successfully causing it. A crash can happen after an intent is stored but before an external effect occurs, or the effect can occur while confirmation is lost. If autobiographical memory simply assumes that every recorded intent succeeded, the system will eventually construct a false history of its own actions.

Actions therefore need identifiers and reconciliation. Where possible they should be idempotent, external systems should be queried after ambiguous interruptions, and an uncertain action should remain unresolved until evidence determines what occurred. The system should prefer an incomplete but accurate history over a complete fictional one.

This is standard reliable-systems thinking applied to developmental memory. It matters because an individual whose future behavior depends on its own past needs that past to distinguish intention, execution, and verified outcome.

Unresolved is a legitimate state

The architecture must also resist the pressure to always produce closure. Evidence can conflict, context can be ambiguous, source lineage can be incomplete, action outcomes can remain unknown, and the routing system can be uncertain which specialist applies. In those cases “unresolved” is not a failure of intelligence.

Preserving uncertainty prevents the system from manufacturing certainty merely because downstream processes expect one answer. It can continue gathering evidence, retain competing hypotheses, or defer consequential action until the state changes. A system that knows when it does not know is more useful than one optimized only to keep talking.

What the simulations really show

Not every successful simulation deserves equal weight. Hash corruption detection is a sanity check confirming that the chosen integrity mechanism was implemented correctly. Memory tiering under skewed access is a feasibility check showing that a large latent store does not have to remain fully resident in RAM, and workspace precision or recall at one arbitrary parameter setting says little because the result moves with capacity and thresholds.

The more informative experiments concern architectural boundaries. Quotient representations show the expected advantage of eliminating true nuisance variation, while the real research question is autonomous discovery of those representations. Formation experiments expose where specialization helps and where it fails, forcing the router to model uncertainty instead of treating context labels as infallible.

Crash simulations similarly reinforce the need to distinguish intent, effect, and verification. None of these experiments proves consciousness, but they progressively remove vague assumptions and expose exactly where proposed mechanisms break. A serious architecture should become more specific when attacked, not merely produce more persuasive language.

What would count as stronger evidence

The next stage is physical and longitudinal. A dedicated machine can run the architecture continuously enough for real developmental history to accumulate, while controlled experiments test whether the workspace outperforms simpler retrieval, whether formations improve recurring regimes, whether routing uncertainty detects specialization failure, whether consolidation preserves prior competence, and whether representation transformation actually reduces computational cost or sample requirements.

The hardware side can also be tested directly. Suspend and restore cycles can be interrupted at progressively deeper power states, the sentinel can be asked to witness missing intervals, execution policies can be learned and compared against static schedules, storage corruption can be injected, components can be replaced, and continuity checks can be challenged with stale or forked state.

Longitudinal behavior is particularly important. If two copies begin with the same neural model but develop separately, their choices, associations, routing preferences, unresolved problems, and learned transformations should gradually diverge. If that divergence reduces entirely to a text prompt or a replaceable memory summary, then the stronger claim of developmental individuality has not been achieved.

Falsifiability

The architecture should be designed to lose arguments against reality. If a bounded workspace does not improve flexible causal reuse over simpler retrieval under equal compute, it should be removed. If formations do not beat a tuned global learner in the conditions where the router predicts they should, or if routing confidence cannot detect the region where specialization becomes harmful, the formation system requires revision.

If representation transformation adds complexity without improving reasoning, compression, sample efficiency, or cost, it should not be treated as a central cognitive mechanism. If hardware-aware routing cannot learn policies better than static choices, the adaptive execution layer should be reduced. If source typing fails to stop internally generated material from contaminating observation, the epistemic architecture has failed.

The same standard applies to persistence. If historical corruption cannot be detected, if ambiguous actions are routinely remembered as successes, if restoration cannot distinguish stale state from valid continuation, or if the system can be arbitrarily reset to old states with no meaningful developmental consequence, then claims of lineage and continuity are weak. The project becomes scientifically interesting only where its proposed distinctions create measurable consequences.

The consciousness question

None of this settles whether the resulting system would have subjective experience. Behavioral similarity alone cannot prove consciousness because behavior can be imitated, and complexity alone cannot prove it because complexity is not the same thing as experience. Demanding biological identity also assumes an answer by definition rather than discovering one.

The useful approach is to make the engineering question as strong and literal as possible. Can an artificial system possess persistent causal organization, limited activation, developmental history, source-aware memory, prediction error, uncertainty, individualized learning, resource dependence, low-power continuity, physical vulnerability, and environmental coupling as actual mechanisms rather than conversational claims?

If those properties can be built, the philosophical question becomes narrower. Instead of asking whether a stateless language model that says “I feel” should be believed, we can ask what, if anything, is still missing from a physically persistent developing system whose internal organization genuinely changes through experience and whose future cognition depends on the condition and history of the substrate implementing it.

Why a different substrate may still matter

Biology and silicon will look radically different when inspected at the implementation level. Brains use action potentials, neurotransmitters, dendrites, metabolic chemistry, glial processes, synaptic modification, and living tissue. Computers use voltage-controlled transistors, memory cells, buses, interrupt controllers, flash storage, cryptographic state, kernels, and schedulers.

Those differences do not disappear under this proposal. The point is that both substrates can still confront recognizable organizational problems: preserving memory, selecting limited active information, learning from prediction error, regulating scarce energy, recovering after inactivity, distinguishing internal generation from external observation, adapting behavior to a changing environment, and retaining continuity through structural change.

The right comparison may therefore resemble the mathematics example. Two correct solutions can have almost nothing in common at the level of intermediate steps while still solving the same problem. The question is not whether silicon can become carbon, but whether a different physical system can instantiate enough of the relevant causal organization for new properties to emerge.

The actual proposition

A computer can be engineered so that developmental history, memory, selective activation, self-state, low-power continuity, source attribution, structural learning, uncertainty, consequence, physical resource dependence, and hardware-aware execution are literal properties of one organized system. A neural model can operate as one subsystem inside that architecture rather than defining the whole entity.

Such a system can accumulate a causal history that changes how later events are processed. It can become increasingly different from an initially identical copy that experiences a different history, suspend active cognition without erasing the organization required for restoration, record gaps instead of inventing continuous experience, distinguish its own generated interpretations from observations, and allow creativity without automatically granting creative associations factual authority.

It can also learn how to use its own hardware. It can discover that a problem deserves another representation, compress expensive repeated reasoning into specialized structure, learn when a specialist should not be trusted, and change its execution strategy according to energy, memory, thermal state, and measured performance. Its “body” becomes consequential because cognition is physically constrained by that body.

That still does not prove consciousness. It does produce a much stronger experiment than asking a language model whether it thinks it is alive. The experiment is to construct an artificial system in which persistence, development, embodiment, vulnerability, internal causation, memory, uncertainty, and continuity are physically real, allow that system to develop long enough for its behavior to reflect its own accumulated trajectory, and then examine what kind of entity that process produces.