Kantian Cellular Automata
A proposal for cellular systems that legislate their own rules
Cellular automata usually begin with a law.
We define a grid, define a neighborhood, define a transition function, and let the world unfold.
Conway’s Game of Life is perhaps the most familiar example. Every cell follows the same small collection of rules. Those rules can create astonishing complexity, but the cells themselves never reconsider them. A cell does not discover that food has become scarce and decide that reproduction should become more conservative. It does not enter a different world and renegotiate how it relates to its neighbors.
The universe evolves.
The law does not.
What happens if we reverse that assumption?
Instead of asking:
What transition rule should every cell follow?
we ask:
What rules should govern how cells are allowed to form their own transition rules?
I’ll call the resulting idea Kantian Cellular Automata.
The name comes from a surprisingly computational reading of Immanuel Kant's idea of autonomy and the Kingdom of Ends. This is not an attempt to claim that cellular automata are moral beings, nor that Kant somehow anticipated artificial life.
It is a design analogy.
And I think it points toward an interesting class of self-organizing systems.
The ordinary cellular automaton
A conventional cellular automaton can be written approximately as
$$x_i^{t+1} = F(N_i^t)$$
where (x_i) is the state of cell (i), (N_i) is its local neighborhood, and (F) is the transition rule.
The interesting complexity comes from repeatedly applying a simple local rule.
But (F) comes from outside the universe.
The designer chooses it.
Even in a Neural Cellular Automaton, where (F) is represented by a neural network and learned through gradient descent, the resulting system generally still executes a learned update rule during deployment. Neural Cellular Automata have demonstrated remarkable properties such as growth, regeneration, and robustness to damage, but the local dynamics themselves are typically optimized externally for a target behavior.
What if the transition rule itself became state?
Suppose each cell has not only a state (x_i), but a policy (\pi_i):
$$x_i^{t+1} = \pi_i^t(N_i^t)$$
and that policy can itself change:
$$\pi_i^{t+1} = G(\pi_i^t, N_i^t, H_i^t, E_i^t)$$
where (H_i) represents history and (E_i) represents environmental conditions such as resource availability.
Now the system is not merely evolving its state.
It is evolving how it evolves.
But arbitrary self-modification is not enough
At first this sounds like ordinary adaptive computation:
let every cell change its rule.
But this immediately creates another problem.
If every cell can independently rewrite its own transition function, what prevents the system from becoming incoherent?
One cell could consume everything around it.
Another could stop participating.
Another could rewrite its behavior in a way that destroys the conditions required by every other cell.
We have removed the externally imposed law, but now we need something one level above it.
Not another transition rule.
A rule about rule formation.
This is where Kant becomes unexpectedly useful.
Kant as a systems designer
Kant's moral philosophy contains several formulations of what he called the Categorical Imperative.
One asks whether the principle behind one's action could be willed as a universal law.
Another says that rational beings must be treated as ends in themselves, rather than merely as instruments for another's purposes.
And in the Kingdom of Ends, Kant asks us to imagine a community in which every rational agent is simultaneously subject to common law and a legislator of that law.
Kantian autonomy is therefore not simply doing whatever one wants.
An autonomous agent is a source of law while also accepting constraints that could apply to other agents with the same standing.
Translated very loosely into computational language:
Each cell may determine its own policy, provided that the policy remains compatible with every other cell having the same capacity to determine its policy.
That gives us an interesting architecture.
The system does not prescribe:
Move here.
Reproduce now.
Consume this resource.
Enter this state.
Instead it prescribes something more abstract:
You may construct your own local behavior, but you may not construct it in a way that destroys the conditions under which neighboring agents can continue doing the same.
This is the basic idea behind a Kantian Cellular Automaton.
From transition rules to constitutions
A normal CA has something resembling a law of physics.
A Kantian CA would instead have something closer to a constitution.
The constitution does not determine every action.
It determines the space of admissible local policies.
We might describe this as
$$\pi_i^{t+1} = G_i(\text{local experience})$$
subject to
$$C(\pi_i, \pi_j, \ldots) = \text{valid}$$
where (C) does not specify the behavior itself.
It specifies constraints on what locally generated behaviors are allowed to become.
For example, the constitutional layer might require that a policy:
preserve some minimum viability of the local agent;
not irreversibly eliminate neighboring agents' ability to participate;
expose resource consumption to reciprocal constraints;
remain compatible with equivalent policy-forming authority in neighboring cells;
be revisable when environmental conditions change.
These are only examples. They are not yet a definition of Kantian Cellular Automata.
The research problem is precisely to discover what such a constitutional layer should contain.
Why this could matter
The immediate attraction is adaptation.
Suppose we train a cellular system on a two-dimensional environment.
A conventional CA often encodes assumptions about the structure of that environment directly into its rule:
$$\text{north}, \text{south}, \text{east}, \text{west}.$$
Moving the same system into a three-dimensional lattice changes the meaning of its neighborhood.
A four-dimensional lattice changes it again.
But consider a cell whose reasoning is expressed instead in terms of:
neighboring agents,
incoming messages,
available resources,
gradients,
histories,
and constraints on reciprocal interaction.
The rule-forming mechanism need not inherently know whether those neighbors live in two dimensions, three dimensions, or an irregular graph.
The topology becomes part of the environment.
That suggests a different ambition:
$$2D \rightarrow 3D \rightarrow 4D \rightarrow graph$$
without redesigning the behavioral law for each world.
The system discovers locally appropriate laws.
This would certainly not mean that arbitrary dimensional transfer automatically works. The learned representation could still encode hidden assumptions about topology.
But it gives us a target:
learn rules at the level of invariants rather than coordinates.
Scarcity should change the law
There is another reason this becomes interesting.
Consider a system trained under abundant resources.
A fixed update rule might discover:
grow whenever possible.
Reduce available energy by 90%, and that same rule may kill the organism.
A self-legislating system has another possibility.
Scarcity changes the local conditions under which policy is formed.
The agents might discover behaviors resembling:
slower growth,
dormancy,
specialization,
resource sharing,
migration,
recycling,
or selective cell death.
The system preserves itself not because the designer anticipated each circumstance, but because the rules governing behavior remain negotiable.
The invariant is not:
always grow.
It might instead be something closer to:
maintain a viable organization under the conditions presently available.
That brings the proposal close to ideas such as homeostasis and autopoiesis: systems that regulate themselves and maintain the organization required for their continued existence.
And this is where the distinction between a learned policy and a self-maintaining world begins to become important.
The cell does not know the organism
One thing I would specifically avoid is giving cells access to a global objective at every step.
If every cell simply receives
$$\nabla L_{\text{global}}$$
then the apparent autonomy is somewhat artificial.
The global designer is still whispering into every cell's ear.
A more interesting version would require cells to operate using predominantly local information.
A cell may know:
what it senses,
what neighboring cells communicate,
its resource state,
a compressed history,
and perhaps some inherited internal structure.
It should not necessarily know what global form is being produced.
The organism emerges because locally formed policies become mutually compatible.
This begins to resemble the way norms can emerge in multi-agent systems, where decentralized agents learn or converge on behavioral conventions rather than simply receiving every behavior from a central authority.
Evolution at multiple timescales
This gives us at least three timescales.
State dynamics
Fast:
$$x^{t+1}=F(x^t)$$
Cells change their immediate state.
Policy dynamics
Slower:
$$\pi^{t+1}=G(\pi^t,\text{experience})$$
Cells modify how they respond to the world.
Constitutional dynamics
Potentially slower still:
$$C^{t+1}=H(C^t,\text{collective history})$$
The system might eventually modify even the constraints under which policy formation occurs.
The third level is dangerous.
If the constitution is fully mutable, nothing prevents the system from eventually deleting the constitutional constraint.
So perhaps some invariants must remain fixed.
That produces one of the most interesting questions in the proposal:
How little must remain immutable for everything else to be allowed to evolve?
This may be the real engineering problem.
A minimal Kantian CA
A first experiment need not be philosophical or complicated.
Imagine a grid in which every cell contains:
$$(x_i,\pi_i,r_i)$$
where
(x_i) is visible state,
(\pi_i) is a small local policy network,
(r_i) is an energy/resource variable.
At each step the cell:
observes neighboring states;
receives messages from neighboring cells;
chooses an action using (\pi_i);
spends or acquires resources;
updates (\pi_i) using its recent experience.
Then introduce a reciprocal constraint.
For example, a cell may consume local resources only while preserving some minimum expected viability for neighboring cells.
Or cells may propose policy updates and locally reject updates that cannot survive symmetric application to neighbors.
That latter version is particularly Kantian:
What happens if every neighboring agent adopts an equivalent policy?
Not as a philosophical slogan.
As an actual local counterfactual computation.
A cell proposes:
$$\pi_i'$$
and before adopting it, estimates:
$$\text{World}(\pi_i' \text{ universally instantiated locally})$$
If that hypothetical destroys the conditions necessary for the agents to continue acting, the policy is rejected.
Suddenly Kant's universalization test becomes an algorithmic primitive.
That is much more interesting than merely naming an adaptive CA after Kant.
A simple experiment
There is an experiment I would genuinely like to run.
Train the system under several environments:
World A: abundant resources
World B: scarce resources
World C: periodic resource collapse
World D: adversarial neighbors
World E: damaged topology
But do not train separate transition rules.
Train the policy-forming mechanism.
Then freeze that mechanism.
Move the population into an environment it has never encountered.
Change the grid size.
Change neighborhood degree.
Move from 2D to 3D.
Remove resources.
Damage half the organism.
Introduce a novel resource.
Then ask:
Does it discover another stable local regime?
Not:
Does it reconstruct the target image?
but:
Does it find a way to continue being a coherent thing?
That difference matters.
From morphogenesis to open-ended worlds
Growing Neural Cellular Automata demonstrated a beautiful idea: complex morphology can emerge through repeated learned local interactions, and those systems can exhibit regeneration after damage.
Kantian Cellular Automata would ask for another step.
Not only:
Can local rules create a body?
but:
Can local agents create and revise the rules by which a body remains possible?
This moves the interesting object from the form toward the organization that generates and preserves form.
Potentially, the same mechanism could support many forms.
Possibly many environments.
Possibly many dimensionalities.
Possibly things we did not specify in advance.
That begins to touch the larger problem of open-ended artificial life.
Why “Kantian”?
The term is intentionally provocative, but it points to something specific.
A Darwinian framing might emphasize:
whichever local rule survives reproduces.
A homeostatic framing might emphasize:
keep certain variables within viable bounds.
An autopoietic framing might emphasize:
continually regenerate the organization that constitutes the system.
The Kantian framing adds something different:
An agent's freedom to establish its own rule is constrained by the requirement that equivalent freedom remain possible for the others.
The emphasis is not merely survival.
It is co-legislation.
Each unit is simultaneously:
autonomous,
constrained,
rule-forming,
and rule-following.
That is the computational structure I want the name to preserve.
This is a proposal, not a field
As far as I can tell, Kantian Cellular Automata is not an established technical term for this architecture.
There are adjacent fields:
adaptive cellular automata,
self-modifying cellular automata,
neural cellular automata,
artificial life,
homeostatic systems,
autopoiesis,
open-ended evolution,
norm emergence in multi-agent systems.
The proposal here sits somewhere between them.
I do not yet know whether the Kantian constraint will turn out to be computationally useful, philosophically superficial, or unexpectedly powerful.
But it gives us a different starting question.
Instead of designing the right behavior:
Can we design the conditions under which behavior can design itself?
And instead of asking a cell merely to obey:
Can we make it participate in writing the law?
That seems worth trying.
A compact definition
Kantian Cellular Automata are decentralized cellular systems in which local agents may form and revise their own behavioral policies, subject to meta-constraints requiring those policies to remain compatible with equivalent policy-forming agency in other cells.
Don’t program the rule. Program the conditions under which rules may emerge.
‒ Pixel
