PaperlayerView exact revision on arXiv

Source-linked AI summary

Dalek: A Constructive Agent Machine

Wanpeng Xie

arXiv:2609.03546v1cs.AI

TL;DR

Agent systems can generate capabilities, but without a constructive definition it remains unclear whether those capabilities belong to the agent, persist, or are inherited. The paper combines von Neumann’s hereditary construction with four machine obligations and a text-and-message substrate to construct Dalek, whose experiments demonstrate persistent, organizational, reproductive, and evolutionary mechanisms while retaining explicit scope limits.

  • Problem

    Generated code may be callable immediately, yet its installation, persistence, restart behavior, inheritance, and authorization can remain controlled by components outside the agent.

  • Method

    Dalek combines von Neumann’s constructor–copier–controller core with actors, messages, channels, four definitional obligations, and a payload composed of a large language model and compiler.

  • Results

    Dalek’s ledger evidence demonstrates self-maintenance, self-evolution, self-reproduction, and self-organization, including inherited capabilities and population-level repair and coordination.

  • Takeaways & Limitations

    Installation, restart, reproduction, and upgrade become constitutive transitions of an individual machine, allowing task capabilities and even machine organs or runtime revisions to participate in heredity.

  • Takeaways & Limitations

    The claims concern organizational effects within the machine; specifications, diagnoses, target selection, and physical effects beyond the declared host contract remain outside its autonomous scope.

Abstract

from arXiv · show

We present Dalek, a closed machine designed for agents that realizes self-maintenance, self-evolution, self-reproduction, and self-organization on any substrate satisfying a general host contract. The machine is built from three primitives---actors, messages, and channels. Four obligations---a host boundary, a construction language, admissible transitions, and rule heredity---give its boundary, identity, and closure a structural basis. Von Neumann's 1948 self-reproducing automaton supplies a hereditary constructional core: a self-description together with a constructor, a copier, and a controller. Dalek combines this core with the four obligations and rederives its medium for a text-and-message agent substrate, adding explicit structures for boundary, identity, history, and growth. A large language model and a compiler occupy the payload position and form a general capability producer. New capabilities are authored, compiled, installed into the description, and inherited by descendants. The same path produces the machine's own organs and even its runtime, closing heredity and evolution within the machine.

1 Introduction

The paper defines an agent machine constructively so open-ended capabilities can become persistent, inherited parts of the system rather than externally managed additions. Dalek is presented as a complete witness satisfying four obligations that support long-running structural change and governance.

  • 1 Introduction: Runtime-generated code becomes part of the agent only when the machine’s construction rules govern its installation, persistence, restart, inheritance, and authorization.Without a constructive machine definition, these properties remain decisions of external loaders, deployment scripts, or operators.
  • 1 Introduction: The four obligations are a host boundary, construction language, admissible transitions, and rule heredity.Together they define the machine’s domain, legal forms, constitutive dynamics, and succession of the rules that generate those dynamics.
  • 1 Introduction: These obligations define a machine class rather than a unique architecture, and Dalek supplies one complete running witness.The paper’s claim is existential: it constructs one system satisfying the obligations jointly.
  • 1 Introduction: Rule heredity is necessary when the rules governing admissible change themselves enter the machine’s domain of change.Open-ended generation alone can use a fixed universal interpreter, but machine-attributed self-modification requires hereditary rules.
  • 1 Introduction: A constitutive boundary limits governance to a finite interface while preserving authorization, audit, revocation, and termination points across generations.The environment cannot rewrite the machine outside admissible transitions, and structural changes can be recorded as explicit transitions.
  • 1 Introduction: Dalek moves installation, restart, reproduction, and upgrade from external maintenance operations into transitions of the machine’s lifecycle.Its organs, runtime, and capability-producing components are contained in the description and can be revised in successors.

2 Constructional Model and Substrate

Dalek inherits von Neumann’s constructor–copier–controller core and adapts it to a text-and-message substrate built from actors, descriptions, channels, and spaces. The adaptation adds explicit mechanisms for identity, history, growth, and an active capability-producing payload.

  • 2.2 From a Constructional Model to an Agent Machine: Dalek treats the hereditary construction as a model to combine with agent-specific obligations rather than as a one-to-one software implementation.The resulting architecture preserves the dual use of G, organ roles, temporal order, and quasi-quiescence while adding boundary, identity, history, and growth.
  • 2.1 The Inherited Construction: Von Neumann’s construction uses a universal constructor A, copier B, controller C, payload D, and description G to produce a copy of the complete machine.G is interpreted by A and copied by B; C orders construction, insertion, detachment, and startup.
  • 2.1 The Inherited Construction: The inherited model assumes a quasi-quiescent description and an environment that supplies the construction’s physics.A description must remain unchanged during copying, while components and their interactions are treated through an environment contract.
  • 2.1 The Inherited Construction: Dalek extends the hereditary core with explicit identity, ledger-based history, and an internal author–validator loop that admits growth into G.The 1948 model produces copies but retains no history and leaves complexity growth open; Dalek addresses these gaps structurally.
  • 2.2 From a Constructional Model to an Agent Machine: In Dalek, actors are parts, text is the description G, channels provide organ boundaries and ledgers, and a Space is the detachable machine.The host Ω supplies execution, storage, and networking, while the inherited runtime R enforces the medium’s laws.
  • 2.2 From a Constructional Model to an Agent Machine: The payload position becomes a general capability producer composed of a large language model and compiler, with text serving as their native input and output.This preserves the constructional division while adapting it to heterogeneous participants that communicate through messages.

3 The Machine

Dalek defines a closed agent machine whose organization, history, construction, and evolution are mediated by explicit internal structures rather than an undeclared host. Its organs turn descriptions into morphology, record activity, reproduce the description, and install tested capabilities that descendants inherit.

  • The Machine: The machine’s three semantic roles are execution, networking, and storage, with reception and atomic append required for independently living, communicating, history-bearing processes.The first implementation uses processes, file inboxes, network endpoints, and append-only files to realize these roles.
  • The Machine: Every recoverable machine state is a fold over append-only ledger history, while effects inside an actor invocation remain outside machine history until emitted across the call boundary.This boundary distinguishes recorded events from local variables, intermediate values, and unrecorded remote exchanges.
  • The Machine: Host-side actions such as file reads and network access are neither recorded nor inherited unless they become ledger rows through the machine’s organizational boundary.The membrane organizes machine effects and history but does not sandbox computation.
  • The Machine: Dalek separates its runtime from both the host and its members: R drives channels, arrives on a blank host, is inherited, and resides in the description’s world field.No member’s medium interface reads or modifies the runtime’s state.
  • The Machine: The machine’s construction laws are executable and substrate-level: organizational renaming preserves behavior, while runtime recognition of members or construction requests would violate the separation.Because every member acts through call, authorization, audit, revocation, and termination have definite locations.
  • The Machine: Rule heredity places transition rules in world, so the machine’s physics travels with every machine and evolves across its lineage.This satisfies the rule-heredity obligation that the 1948 model leaves in its substrate.
  • Organs, Heredity, and Growth: Dalek distributes constructor, copier, and controller roles across c0, adds c1 as a registry, and uses c2 to author new capabilities; the minimal c0,c1 machine reproduces, while c2 enables variation.c0 realizes, packs, and sequences construction; c1 folds its ledger into the description; c2 supplies authored capability growth.
  • Organs, Heredity, and Growth: Universality belongs to realize, which accepts every legal description, while capability growth adds members rather than increasing underlying computational power.The capability producer turns what L and Exec can already compute into named, addressable, restartable, reproducible members.

4 The Machine in Operation: From One Task to a Third Generation

Dalek demonstrates that capabilities, repairs, topology, runtime rules, and altered worlds can enter the machine through its construction path and persist across descendants. Across the experiments, organizational change is inherited through descriptions and ledgers, while host-side effects and autonomous choice remain outside the machine.

  • 4.3 A Population (E2): Self-Organization and Self-Maintenance: Three machines grow mutual doors from an inherited protocol; heartbeats repair lost contact, and a neighbor wakes a killed machine from its own ledger.The ecology shares neither ledger nor morphology, and no external party writes its topology.
  • Scope and Boundary: These experiments provide machine-mediated change and inheritance, but tasks, specifications, diagnoses, and judgments about desired changes remain supplied from outside the membrane.Autonomous choice of what to change is explicitly not tested.
  • 4.2 One Task, End to End (E1): A new capability enters through a door, is installed by R, registered, and becomes the next invocation, with two failed candidates recorded before success.The path took approximately ninety seconds and six HTTP rounds across two invocations.
  • 4.2 One Task, End to End (E1): The installed file becomes named, addressable, persistent, reusable, and heritable, unlike an equivalent operation executed only inside the universal executor.The offspring inherits the member byte for byte, but not the host-side notes.txt file.
  • 4.3 A Population (E2): Self-Organization and Self-Maintenance: A spelling error disables remote maintenance, but diagnosis enters through a door and the machine replaces the live reporter by adding, retiring, and installing a repaired member.The new reporter restores the spawn loop and produces a spawn receipt.
  • 4.4 A World (E4): Hereditary Rule Change: A rewritten C changes the offspring’s world: every descendant ledger row receives w: 2 while the inherited C remains byte-identical and the patch does not accumulate.The parent remains unchanged; world' takes effect only in the offspring.

5 Discussion

Dalek relocates agent lifecycle authority from a model-centered periphery into a machine whose members, transitions, history, and heredity are explicitly defined. Its main gain is constitutive rather than computational: capabilities become installed, persistent, replaceable, and inheritable machine members.

  • Agent and machine: Dalek replaces the model-plus-periphery configuration with a machine plus members, making lifecycle transitions and constitutive authority explicit.Triggers and materials may come from outside, but installation, upgrade, reproduction, continuation, history, and heredity are defined by the machine.
  • Agent and machine: The task loop remains an ordinary member of the machine rather than its organizing center.The organizing center shifts from the task loop to the lifecycle while preserving the task loop itself.
  • Four scales of self: The four self-properties operate at individual, generational, and population scales, while the language model authors candidates and requests installation.Maintenance concerns morphology and capability, reproduction copies G, evolution completes through inherited installation, and organization constructs inter-machine topology.
  • Capability and constitution: With Ω and L fixed, installing a new member does not increase computational expressiveness; it increases constitution through registration, persistence, availability, heredity, and replacement.The capability axis remains fixed, while the constitutive axis accumulates machine members and their records.
  • Capability and constitution: Machine complexity grows in G rather than R, allowing arbitrarily many members and organs without enlarging the runtime's structural branching.This follows the universal-constructor pattern in which more complex objects lengthen their descriptions rather than their constructors.
  • Costs and limits: Dalek forbids overwriting and does not preserve volatile scene state or history across restart and reproduction.Modification uses addition and retirement; Σ resets on restart, offspring history begins empty, and individuals may die without successors.

6 Related Work

Dalek connects agent-machine design to harnesses, runtimes, operational semantics, recursive self-improvement, reflection, autopoiesis, and von Neumann constructions. It differs by defining a lifecycle subject whose boundary, constitutive transitions, history, and successor rules are jointly specified.

  • Relation to prior work: Prior work studies task loops, managed processes, improvement procedures, running configurations, processor-centered computers, or self-simulating models, whereas Dalek defines a lifecycle subject.That subject combines individuation, constitutive change, history, and succession under an explicit machine boundary and transition system.
  • Agent systems: Harnesses and agent runtimes externalize orchestration, evaluation, permissions, process identity, checkpoints, recovery, and execution traces in different combinations.These systems address neighboring lifecycle and authority problems without supplying Dalek's joint construction.
  • Formal and systems foundations: Operational-semantics and kernel traditions provide precedents for inductive transition relations, synchronization, exhaustive testing, and separating policy from mechanism.Dalek uses configurations plus an inductively defined transition relation for its machine state and admissible transitions.
  • Self-improvement and construction: Recursive self-improvement work varies the changed object, evaluator, and retention mechanism, while von Neumann's construction separates description, constructor, and copier.Dalek extends these ideas from model-centered or program-centered improvement to a material agent machine with inherited construction rules.
  • Relation to prior work: Dalek inherits mechanisms from several traditions but does not claim those prior works as the source of its construction.Its distinctive object is a bounded lifecycle subject whose runtime specifies constitutive transitions and whose successor inherits the rules for producing successors.
  • Relation to Dalek: The language model is an ordinary member that can be replaced, maintained, and inherited through the same path as other members.This separates the model's authorship role from the machine's constitutive organization.

7 Conclusion and Future Work

The conclusion presents Dalek as a constructive witness for agent machines whose capabilities, organs, and runtime enter a common hereditary lifecycle. Future work extends that architecture toward explicit norms, internal capability production, recursive organization, and portable organizational fragments.

  • Conclusion: Dalek supplies a constructive definition of an agent-machine class and a running witness with explicit members, boundary, history, and constitutive transitions.The language model is an author inside the machine rather than the organizing center around which peripheral structure is arranged.
  • Conclusion: Maintenance, evolution, reproduction, and organization are four directions of one lifecycle spanning individual, generational, and population scales.The machine defines how changes become part of it, persist, recover, and enter heredity, while tasks and value judgments may remain external.
  • Conclusion: New capabilities, organs, protocols, and the runtime can enter self-description through the same installation path and be inherited without requiring runtime growth.Complexity grows in G, while construction and heredity remain governed by the machine's existing architecture.
  • Future work: An explicit specification layer could let the machine preserve norms while changing implementations and inheriting contracts, acceptance conditions, and governance rules.The present machine repairs against targets supplied by G, history, or an external specification; the proposed extension would make satisfaction relations explicit.
  • Future work: Capability production could be progressively internalized by unfolding the compiler and model into organs for building, testing, training, evaluation, and rollback.External services may remain in Ω, while selected production infrastructure becomes replaceable, recoverable, and heritable machine organization.
  • Future work: Encapsulation and refinement protocols could let organs become machines and machines become organs while preserving specified observations across replacement.The same actors-and-messages primitives would support recursive organizational growth and governance at multiple scales.
  • Future work: Portable G fragments could package inspectable, maintainable, composable, and heritable organizations for acceptance and recombination across lineages.The proposed unit of reuse ranges from compiler and test organs to research pipelines and internal governance structures.

Notation

The notation defines Dalek's identity, runtime, host boundary, organs, ledgers, targets, and construction units. It distinguishes inherited description from individual history and volatile runtime state.

  • Identity and state: An individual is (G, H), while a running machine is (G, H, Σ); G answers what the machine is, H which individual it is, and Σ resets on restart.One machine is one Space driven by the runtime R it carries and runnable on a host satisfying Ω.
  • Host and runtime: Ω supplies destination execution, storage, and networking as a host contract that does not travel with the machine.The host boundary determines which mechanisms belong to the machine and which remain assumptions of the destination.
  • Roles and organs: R is the inherited structural fixed point that instantiates actors, delivers messages, folds ledgers, and executes syscalls while remaining blind to function and organization.G stores the machine's self-description, C sequences construction, and D produces general capabilities from L and U.
  • Roles and organs: L authors capability candidates, U compiles them into installable parts, c0 interprets G, and c1 stores G as the registry ledger.The model is an ordinary replaceable member, while the compiler is separate from authorship and construction is routed through c0.
  • Morphology and targets: G_t is heritable morphology, M_t is currently alive morphology, and Q is the maintenance target supplied by description, history, or an external specification.The provenance projection π relates actual morphology to the inherited description at rest.
  • Construction vocabulary: Actors, messages, channels, and Space are the basic construction units, while syscalls write morphology and spawn and stop operate on the world.A member is an actor registered in a channel, and anything beyond the machine boundary lies outside its membrane.

A.1 State and Event

State is organized as append-only channel ledgers plus one cursor per actor, while events invoke addressed members and advance cursors.

  • State comprises one append-only ledger per channel and one cursor per actor.
  • Each event is an addressed message row without a run marker and invokes its member once to completion.Nested calls form the call stack; only events advance a cursor.

A.2 Complete Transition Table

The transition table defines actor loading, message execution, replies, addressing, installation, channel operations, retirement, spawning, and shutdown.

  • Exec.load executes source once and requires it to define run(m) over a structured message record.The record contains seq, from, to, body, and channel.
  • A run invocation returns its value as the reply, with None or an empty value meaning no reply.
  • Addresses may be absent or textual endpoints, while Port.send delivers unchanged messages and stamps the current channel endpoint.
  • Installation allocates a unique routing tag, adding a numeric suffix on collision, and records the complete actor text in a place row.
  • Channel creation, actor retirement, spawning, and stopping are exposed as operations, with addresses never reused and the current receptionist unable to retire.

A.3 Address Space of call

Calls use channel-local member tags resolved at call time, alongside open reads, external doors, channel operations, and world bindings.

  • A member tag is resolved at call time within the current channel.
  • Reads can expose ledger rows or the current member table to every member while recording only a fact row.
  • Door-tag calls send outside the membrane and return empty, while channel operations include creation, actor addition, and actor retirement.
  • Spawn and stop operate on same-named world bindings.
  • Calls to nonexistent addresses are discarded; calls to members run synchronously and return the member’s reply.

A.4 Ledger Rows

Each channel uses a single-writer JSON Lines ledger whose rows record execution, installation, messaging, facts, and invocation closure, while addresses distinguish physical and logical identity.

  • Each channel has one JSON Lines file written by its local runtime.
  • Execution rows contain complete actor text, while retire rows record the retiring sequence and address.
  • Place rows record sequence, address, kind, text, binding, provenance, tag, and optional interface fields.
  • Ledger entries include requests, replies, door-copied messages, syscall receipts, and fact rows; run identifies the containing event and at identifies the inbox offset.
  • Invocation-closing rows capture the cause, every emitted frame, and any exception, with step rows recording actor, extent, output, errors, and run.
  • The medium stamps message origins, while physical addresses increase without reuse or inheritance and logical channel/tag addresses are inherited.

A.5 Root Door and Inboxes

The root door is an explicit ledger-derived boundary that exists before channels and governs initial channel, actor, and message creation.

  • Inboxes: Every channel has an inbox, and an arrival becomes a message for the member whose place row carries the in mark.
  • Root door: The root door belongs to R at Space level, exists before every channel, and is absent from G.
  • Lifecycle: The door is open exactly when no ledger contains a message row, and the first start message closes it.While open, it accepts channel.create and channel.add.actor operations recorded with by=_root.

A.6 Packaged Form 𝑃and Startup

The packaged form P contains the generated world, description, ledgers, inboxes, and offspring structure, while startup folds existing ledgers and drives the machine without reading G.

  • Packaged form: P contains runtime files byte-identical to G.world and a description unchanged from G.The packaged runtime includes P/omega.py, runtime.py, and init.py, while P/G.json preserves the description.
  • Packaged form: Build artifacts include compiled capability ledgers under P/h and a medium boot index in h/_order.These files are produced by B.
  • Runtime state: Runtime creates inboxes for _root and every channel, and reproduction creates offspring under P/spawn/<name>.
  • Startup: Running python init.py <P> [--serve] starts R, folds existing ledgers, and drives without reading G.

B Evidence Index

The evidence index identifies experiment records, their authors, file locations, and sections, while preserving original ledgers and noting historical semantic differences.

  • Evidence records: The released ledgers and evidence/runs snapshots contain the original records cited by the tables in §4.Credentials are redacted, and original records are not rewritten.
  • Historical scope: E1 and E2 predate tag addressing and tightened lifecycle semantics, so their external receipts and restart behavior use earlier conventions.
  • Lineage evidence: The index lists parent, offspring, and grandchild evidence for E1-b and E5-b across their corresponding JSONL files.
  • Lifecycle evidence: E2-b and E2-c records cover installation, self-organization, defect, wake, repair, and d2 activity across task1-d0 through task1-d2 files.
  • Mechanism evidence: E3 and E4 are identified as mechanism-layer stubs with drivers, including local damage, shutdown/wake, hard kill, and test_c0.py.
Loading 2609.03546v1…