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.

Property	Value
Parameters	1,182,064
Transformer layers	4
Attention heads	4
Hidden dimension	160
Feed-forward dimension	512
Input feature width	310
Operation classes	13
Framework	PyTorch

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

Black-box experiments	Exact next-state accuracy
0	15.9%
1	17.2%
2	27.5%
5	30.6%
10	59.4%
20	66.6%
30	65.0%

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:

Black-box experiments	Exact next-state accuracy
0	16.9%
5	36.6%
10	50.9%
20	90.0%
30	94.1%

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.

Bhargavi-Kurukunda
/

machinezero-small