machinezero-small

MachineZero-Small

A 1.18M-parameter Transformer trained to infer the hidden semantics of computers it has never seen before.

MachineZero-Small is the learned model behind MachineZero, an open research project exploring active system identification across completely unseen computational architectures.

Instead of receiving an instruction set specification, the model is given a limited number of black-box experiments on a procedurally generated AlienCPU:

state + opaque instruction → resulting state

From those observations, MachineZero must infer what the unknown instruction does and predict the result of a new execution.

AlienCPU vs. MachineZero

These are two separate components.

AlienCPU is the unknown computer.

Each AlienCPU can vary in:

• opcode mapping
• instruction subset
• operand direction
• flag-update behavior
• word size
• number of registers

The instruction semantics are hidden from the model.

MachineZero-Small is the model attempting to identify those semantics from observed executions.

The held-out object is therefore not simply another sample.

It is an entirely different computer.

---

Model

MachineZero-Small is a Transformer trained from scratch.

The model does not directly generate the next register values.

Instead, it predicts latent instruction semantics:

• operation class
• operand direction
• whether the instruction updates the zero flag
• whether the instruction updates the carry flag

A deterministic generic executor then applies those inferred semantics to predict the next CPU state.

This makes the system a small neuro-symbolic system-identification model rather than a direct state regressor.

---

Training Setup

Training uses procedurally generated AlienCPU architectures.

• 48 training architectures
• 8 validation architectures
• 8 test architectures
• 48 training samples per architecture
• context length up to 5 observed transitions
• architecture-level train/validation/test isolation

The validation and test AlienCPUs use architectures not present during training.

The model therefore cannot rely on memorizing a fixed ISA.

---

Results

Evaluation is performed on 8 completely held-out AlienCPU architectures, with 40 prediction queries per architecture.

Learned Model

At a budget of 20 experiments:

• Exact next-state accuracy: 66.6%
• Register accuracy: 97.5%
• Operation-class accuracy: 81.6%

Exact-state accuracy requires the predicted registers, flags, and program counter to all agree with the hidden simulator.

Explicit System-Identification Baseline

MachineZero also includes a hypothesis-elimination baseline that enumerates possible instruction semantics and removes hypotheses inconsistent with observed transitions.

With coverage-based active exploration:

The strong symbolic baseline is an important result of the project rather than something hidden from the comparison.

AlienCPU currently has a compact enough semantic space that explicit hypothesis elimination works extremely well. One direction for future work is studying architectures where the latent behavior becomes too large or continuous to enumerate explicitly.

---

What the Model Sees

Each context transition is represented using observable execution information including:

• padded register state
• flags
• program counter
• opaque opcode identity
• instruction operands
• query/context markers
• architecture-independent consistency features derived from observed state transitions

The model does not receive:

• the AlienCPU seed
• the hidden opcode-to-operation mapping
• the ISA specification
• semantic labels at inference time

---

Open-Model Demo

The demo below generates a held-out AlienCPU, allows MachineZero twenty black-box experiments, and asks it to predict a new execution.

Video: https://youtu.be/whDJ0_Ksd9w

Example:

NEW ALIEN CPU

Architecture     #925303
Word size        8 bits
Registers        6
Unknown opcodes  8

Hidden ISA
0x8F → ???
0x6C → ???
0xC9 → ???
...

EXPERIMENTING
20 black-box experiments

UNSEEN TEST

Predicted    [156, 103, 244, 244, 154, 162]
Actual       [156, 103, 244, 244, 154, 162]

✓ EXACT MATCH

---

Download and Run

MachineZero can download this checkpoint directly from Hugging Face.

git clone https://github.com/Bhargavi-hash/machinezero
cd machinezero

pip install -e .

Download the model:

machinezero pull small

Run it against an AlienCPU:

machinezero run small --seed 2026 --budget 20

Or run the judge-facing demo:

python -m machinezero.judge_demo --seed 2026 --budget 20

---

Checkpoint Contents

The released checkpoint contains:

• trained model state
• model configuration
• training configuration
• data configuration
• architecture split metadata
• parameter count
• training history

The released model has 1,182,064 parameters and expects the current MachineZero structured-semantics input representation.

---

Intended Use

MachineZero-Small is a research prototype for studying:

• active system identification
• learning across unseen computational architectures
• hidden instruction-semantic inference
• experiment selection under limited interaction budgets
• hybrid learned + symbolic execution

It is not intended to emulate or reverse engineer production CPUs.

AlienCPU is a controlled synthetic environment designed to make architecture-level generalization measurable.

---

Limitations

The current AlienCPU semantic space is intentionally small and enumerable.

MachineZero-Small is also a small research model trained on only 48 training architectures. Its exact-state accuracy remains substantially below the explicit system-identification baseline.

The model currently operates on synthetic CPUs rather than real hardware, and the project does not claim production-level ISA discovery or hardware reverse engineering.

The current learned model also shows a small decline from the 20-experiment to 30-experiment setting because it was trained primarily with short contexts.

---

Why MachineZero?

Most ML evaluation holds out examples from a known task distribution.

MachineZero instead asks whether a model can encounter a new computational system, interact with it, infer its rules, and predict its behavior.

The held-out object isn't just a test example. It's the machine.

---

Links

• Code: https://github.com/Bhargavi-hash/machinezero
• Demo: https://youtu.be/whDJ0_Ksd9w
• Model: Bhargavi-Kurukunda/machinezero-small