Dalek: A Self-Sustaining Constructive AI Agent

A new claim in agent architecture

Dalek enters the AI-agent debate not as another task bot, benchmark runner, or coding harness, but as a proposed machine model for agents that can change while remaining structurally legible. The paper, submitted to arXiv on September 3, 2026, frames Dalek as a closed agent machine capable of self-maintenance, self-evolution, self-reproduction, and self-organization on any substrate satisfying a host contract [1]. That phrasing is ambitious, but the important point is architectural: Dalek is less a product announcement than a formal design for deciding when generated capabilities become part of an agent, how they persist, and how they are inherited.

The preprint, titled “Dalek: A Constructive Agent Machine,” lists Wanpeng Xie as author and places the work in artificial intelligence [1]. The same paper is also available in PDF and experimental HTML forms, where the subtitle emphasizes “self-maintenance, self-evolution, self-reproduction, and self-organization by construction” [2]. Fresh indexing sources surfaced the entry among September 4 arXiv listings, confirming that the subject’s current public footprint is centered on this newly posted preprint rather than on an accompanying commercial release or independent benchmark report [4].

From agent inventory to machine definition

The motivation begins with a familiar problem in modern agent systems: as tasks become more open-ended, engineers add memory, tools, validators, subagents, workflows, gateways, and deployment scripts around a language model. Dalek’s paper argues that this “inventory” approach buys capability at the cost of system complexity [3]. A more dynamic alternative is to let models generate code, plug-ins, or workflows at runtime, but the paper says that this only moves the problem: generated code may run, yet the decision about whether it has become part of the agent is often left to external loaders, file systems, image builders, or human operators [3].

Dalek’s answer is to define an agent as a constructive machine with explicit membership rules. In this view, an agent is not simply a loop that calls a model and tools. It is an entity whose boundary, legal forms, legal transitions, and hereditary rules are stated inside the architecture. The paper calls Dalek a “complete running witness” for a class of machines satisfying four obligations: a host boundary, a construction language, admissible transitions, and rule heredity [3].

This is the conceptual shift. Dalek is designed to make lifecycle operations—installation, restart, repair, reproduction, and upgrade—part of the machine rather than maintenance activity around the machine [3]. The result is a model of agency organized around the continuity of an individual system, not merely around the completion of a task.

The four obligations

Dalek’s first obligation is the host boundary. Every mechanism that can affect a claimed property must either belong to the machine or be explicitly assigned to the host environment, called Ω in the paper [3]. This matters because many AI agents depend on hidden infrastructure: orchestration scripts, external storage, deployment logic, human-triggered restarts, and tool permissions. Dalek’s architecture tries to remove this ambiguity by declaring what is inside and what remains outside.

The second obligation is a construction language. Legal machine forms must be generated from finite primitives and finite composition rules [3]. This does not mean that the agent’s future capabilities are fixed in advance. Instead, it means that newly generated capabilities must enter the machine through a defined language that governs how they are installed, persisted, and represented.

The third obligation is admissible transitions. The paper requires explicit operations that map one legal machine state into another legal state [3]. This is crucial for self-modifying systems: if an agent can rewrite parts of itself but the valid rewrite operations are not specified, there is no stable basis for saying that the resulting system remains the “same kind” of machine.

The fourth obligation is rule heredity. If improvement is attributed to the machine itself, then the rules for building valid successors must also be representable, constructible, and heritable [3]. Dalek separates the current construction from revised rules written into successors, avoiding the circular idea of a system rewriting the very rules that define its own present construction at the same instant [3].

Primitives: actors, messages, channels

Dalek’s working medium is built from three primitives: actors, messages, and channels [1]. Actors are the components; messages are the mode of interaction; channels provide organizational boundaries. The paper’s reason for this choice is that agent systems already deal in heterogeneous participants—models, programs, tools, humans, services—and a message interface can present these different entities through one constructional form [3].

The paper also introduces a description, G, and a history ledger, H. G represents what the machine is supposed to be, while H records what the machine has undergone [3]. This pairing lets Dalek distinguish between a constitutive blueprint and the record of changes, births, repairs, and organizational events. The machine’s identity is therefore not just a running process. It is the combination of description and history.

A runtime, R, defines the constitutive transitions, but the paper stresses that this runtime is meant to be blind to function and organization [3]. In other words, Dalek’s transition system should not depend on knowing the meaning of each task capability. It should know how to add, remove, call, record, package, restart, and reproduce components according to rules.

The von Neumann lineage

Dalek explicitly borrows from John von Neumann’s 1948 self-reproducing automaton rather than from the better-known stored-program “von Neumann architecture” [3]. In the inherited model, a universal constructor A builds from a description G, a copier B copies the description, and a controller C coordinates construction, copying, insertion, detachment, and start-up; D is a payload outside the core reproductive mechanism [2].

The Dalek paper adapts this scheme to agent systems. The constructor, copier, controller, and capability producer are contained in the description, so a current generation can construct a successor that carries revised organs and potentially a revised runtime [3]. In the agent setting, the payload position becomes especially important because a large language model and compiler can act as a general capability producer [1]. New capabilities are authored, compiled, installed into the description, and inherited by descendants [1].

This is where the claim becomes more than “an agent can write code.” Dalek’s point is that generated code is not automatically self-improvement. It becomes a machine-level change only if there is an authorized path by which the capability is admitted into the description, survives restart, and is inherited by descendants.

What Dalek says it demonstrates

The paper’s operational section describes Dalek moving from one task to a third generation and presents ledger evidence for self-maintenance, self-evolution, self-reproduction, and self-organization [2]. It includes scenarios involving a population, an offspring with a new runtime that reproduces, a lost controller that is rewritten and used by two generations, and crash, shutdown, and damage paths [3]. These are not public industry deployments; they are evidence artifacts within the preprint’s constructed system.

That distinction matters. The current state of the subject, based on fresh public sources, is that Dalek is a newly disclosed research preprint with internal architectural and ledger evidence, not a widely validated platform with external replication, third-party audits, or production performance data [1]. The paper’s contribution is therefore best read as a proposed constructive definition and existence witness for a machine class, not as proof that fully autonomous, safe, self-improving agents are ready for deployment.

Governance surface and safety implications

Dalek’s governance argument is one of its most relevant features. If every organizational effect between the machine and the environment passes through a finite interface, monitoring and intervention can focus on that governance surface [3]. The paper argues that the environment cannot rewrite the machine outside admissible transitions, while the machine’s external organizational effects gain explicit points for authorization, audit, revocation, and termination [3].

This is a useful response to a central AI-safety concern: self-modifying agents are hard to govern if their boundaries are unclear. Dalek does not solve safety by saying the model will behave well. It tries to make the places where change can occur finite, named, and auditable. But the paper also limits its own claims. It focuses on organizational effects—members, messages, doors, and constitutional changes—not every physical or network effect an actor might produce during execution [3]. Extending the same guarantees to all physical effects would require a stronger host contract [3].

Limits of the current evidence

Dalek’s design raises several open questions. The first is verification: ledger evidence can show that specified transitions occurred, but broader confidence would require independent implementations, adversarial tests, and formal analysis of whether the transition rules preserve the properties claimed. The second is containment: a system that can author and inherit new capabilities needs strong controls around what capabilities may be admitted, what proofs or tests are required, and how rollback works.

The third is substrate realism. Dalek is written as a machine that can run on any substrate satisfying the host contract, but real substrates differ in storage guarantees, process isolation, permission models, network exposure, and failure modes. The fourth is evolutionary pressure. Once descendants can carry revised organs and runtimes, developers need a way to distinguish useful adaptation from drift, bloat, or specification erosion.

The preprint itself names future work in conservative extensions, including putting specifications in the description, making authoring and validation components into machines, treating machines as actors, and sharing or propagating fragments of capability [3]. Those extensions indicate that Dalek is still a research architecture with a roadmap, not a settled standard.

Why it matters

Dalek is notable because it changes the question from “Can an AI agent do more tasks?” to “What makes an AI agent a continuing machine through change?” That distinction is increasingly important as agent systems generate code, add tools, spawn subagents, and run over longer time horizons. Without a constructive definition, self-modification remains operational folklore: something happens in the surrounding stack, and the agent appears improved.

Dalek proposes a stricter account. A capability counts when it is constructed through finite rules, installed by admissible transition, recorded in history, and inherited through a defined reproductive path. Whether that model becomes influential will depend on replication and critique. For now, its current public state is clear: a newly posted arXiv preprint proposing a self-sustaining constructive AI-agent machine, with the central novelty lying in the architecture of boundary, heredity, lifecycle, and governance [1].

Sources from the last 72 hours

1. [1][2609.03546] Dalek: A Constructive Agent MachineSep 3, 2026, 8:46 AM UTC
2. [2]Top arXiv papersSep 4, 2026, 12:00 AM UTC
3. [3]Dalek: A Constructive Agent MachineSep 3, 2026, 8:46 AM UTC
4. [4]Dalek: A Constructive Agent MachineSep 3, 2026, 8:46 AM UTC

AI-generated article based on recent web research, then preserved as a dated editorial snapshot.