Alpha is built for agents#

Alpha's purpose is to take a whole learning system—the model, the learning rule, the schedule, the memory plan, the host driver, and every GPU instruction underneath—apart into pieces small enough to be named in plain language, and to make the compiler fast and strict enough that an agent can put those pieces back together in new shapes many times an hour.

The agents doing that work are language models. They are extraordinarily good at natural language and at recombining named things, and comparatively poor at holding an unnamed encoding in their heads. Alpha is designed around that asymmetry.

The whole point: deconstruct everything into natural language#

Most stacks bury their meaning. A training loop is a Python object, a kernel is a vendor binary, a launch is a CUDA call, an instruction is a 128-bit word whose fields are documented nowhere public. An agent can only rearrange what it can see and name, so on such a stack it rearranges the same top-level knobs everyone else does.

Alpha refuses hidden layers. Every piece of a physical training system is an ordinary checked definition with a full literal name:

• a GPU instruction is SM86FloatFusedMultiplyAdd, SM86LoadSharedMatrix, SM86WarpShuffle, SM86TensorCoreHalfMatrixMultiplyAccumulate16x8x16Float32—not FFMA, LDSM, SHFL, HMMA.16816.F32;
• a host command is NativePhysicalSystemCall, NativePhysicalRepeatBegin, NativePhysicalStoreWord64, NativePhysicalLoopAffine base stride;
• a launch is a typed NvidiaWholeProgramPlan with named regions, a launch schedule, and submissions;
• a device is a typed profile: runPodRTX3090TargetProfile, its compute capability, its memory, its command-stream constants;
• a learning rule is a definition the agent can read: Bob's AdamW scalars are computed in source with f32-sqrt, not pasted as bytes.

When every piece is named, the design space stops being "the options the framework exposes" and becomes "every recombination of every named thing". That is where novel concepts come from. An agent that can read SM86ReduceGlobalAddFloat32 next to SM86BarrierSynchronize next to NativePhysicalRepeatBegin can propose a reduction, a synchronization pattern, or a host protocol nobody has written yet—and the compiler will tell it, by name, exactly which boundary the idea crosses.

The goal is to get out of past ways of thinking. Not by forbidding the Transformer or the GPU, but by making them one more set of named parts on the table.

A very literally literal language#

Alpha's surface syntax is deliberately literal. Programs are S-expressions of full words. There is one form for one meaning, and the words in the form say what happens:

(constructor NativePhysicalOperation NativePhysicalRepeatBegin
  (modelWord64FromNaturalTruncated 164))

There are no operator-precedence tables to remember, no implicit coercions, no overloaded symbols whose meaning depends on the surrounding types. Family constructors, fields, and definitions are spelled out (sm86LoadGlobalDestination, nativePhysicalRepeatBalance, coppeliusHostSubmitAffine). Numeric literals carry their type. Byte strings are byte strings.

This looks verbose to a human and it is exactly right for a language model. A model's strength is reading and writing natural language; a literal language lets it use that strength on the whole program, including the machine layers, instead of on a thin script above an opaque runtime. It can grep for a concept by its name, explain a kernel line by line, and rearrange instructions with the same ease it rearranges sentences. It rarely has to decode.

The trade is intentional: Alpha gives up terseness to gain a vocabulary the agent can reason in.

Fast compilation, so iteration is cheap#

An agent iterates as fast as it gets answers. Alpha's Stage-0 compiler is built to answer quickly:

Checks are cached per module and per receipt, so an agent's usual loop—edit one definition, check, read the diagnostic, edit again—runs at conversational speed. When it has a candidate, one command produces a self-contained ELF that drives the GPU through the NVIDIA kernel driver's resource-manager and unified-memory interfaces with no external userspace runtime dependency (the executable carries its own 2.7 KB command interpreter, and it still depends on the vendor kernel driver and firmware), and a receipt that binds it to the source and compiler identities.

Types, so iteration is safe#

Speed without a reviewer produces plausible garbage. Alpha's type checker is the fastest and least forgiving reviewer an agent can have:

• dependent types state relationships between shapes, indices, extents, and evidence, so a kernel that reads past its arena or a schedule that launches more grids than the plan declares fails at check time with a named diagnostic;
• quantities (erased, linear, affine, unrestricted) make resource use part of checking, so an agent cannot silently duplicate a buffer or drop an effect;
• the compiler fails closed: there is no host fallback, no compatibility shim, no silent degradation. If a target lacks a capability, the build refuses with the requirement's name;
• eliminators must be exhaustive and in declaration order, so adding a constructor to the instruction set immediately points at every place that must learn about it.

For an agent this means that the second message in a conversation with the compiler is usually the exact thing to fix. It can afford to be bold with the design because the checker is strict with the consequences.

What "typed" does and does not mean here: the checker proves well-formedness — exhaustive eliminators, quantities, plan extents and launch counts, device admission. It does not yet prove that a backward kernel computes the derivative of its forward kernel or that a checkpoint resumes the same optimizer trajectory. Every physical claim Alpha makes is tagged as one of four things: proven by the types, asserted at run time by the executable (which exits with the failing check's name), tested (a differential or contract in CI), or not captured at all. The evidence and statusEvaluate · analysisEvidence and statusHow to read checked, self-hosted, and physically attested claims. page keeps that separation.

Devices are first-class, and fully profiled#

Every device Alpha targets gets its own page, so that an agent choosing a target knows what it is working with: identity, compute capability, memory, the command-stream constants the compiler uses, which systems have been qualified on it, and its measured profile. Profiling has three tiers:

1. Driver facts — what the resource manager reports: product identity, capability bits, memory, mappable address range, timestamp support. Exact-device admission today checks product identity, capability bits and memory; ABI, feature and resource assumptions are not yet part of the contract.
2. Micro-benchmarks — measured instruction and memory behaviour: issue rates, latencies, shared-memory bandwidth, global bandwidth by access pattern, tensor-core throughput, submission and fence round-trip cost.
3. Model-shaped calibration — the cost of the actual kernels and launch schedules Alpha emits, so the compiler can choose realizations from measurements rather than assumptions.

The driver-fact tier is live; the measured tiers are not yet run on any card. Each device page says which is which. The point is that "what can this GPU do" becomes a typed, named fact the agent can read, rather than folklore.

What this does not claim#

Literal names do not make a program correct, fast compilation does not make an idea good, and a strict checker cannot tell whether a model learns. Alpha's bet is narrower: if every piece is named, checked, and cheap to recombine, then an agent's creativity gets applied to the right layer and its mistakes are caught in seconds rather than after a night on a GPU. Physical results are still established only by physical runs with retained evidence—see Evidence and statusEvaluate · analysisEvidence and statusHow to read checked, self-hosted, and physically attested claims..

Read next#

• The philosophy behind AlphaUnderstand · analysisPhilosophyWhy Alpha reopens the design space for agents instead of freezing today's AI stack.
• How learning systems are expected to workUnderstand · analysisLearning systemsHow Alpha is meant to turn learning ideas into checked, comparable physical experiments.
• How the language and compiler workUnderstand · analysisLanguage and compilerHow source becomes checked core, typed machine work, native artifacts, and evidence.
• Devices