ARTI

THE ARTI RUNTIME

A program for neural computation.

ARTI separates the declaration of computation from its learnable operands and forward state. Formula Fabric executes the mathematics; ProgramGraph connects the resources; backend bindings and task workflows carry it into an application.

THREE DIFFERENT LIFETIMES

Computation has a definition. Values have an owner.

Static declaration

FormulaProgram / ProgramGraph

Named axes, operand types, operations, ports and declared execution structure. A program fingerprint identifies that computation contract.

Learnable values

Bank operands / parameters

Numerical operands receiving credit from the task objective. Parameter ownership determines which optimizer domain can update each value.

Forward state

Resources / carry / Bank revisions

Values read or produced during execution. Functional successors are returned separately; persistent writes follow the declared commit protocol.

ORDINARY OPERATIONS. NEURAL STRUCTURE.

Compose the mathematics.

The gated recurrence is built from Add, Scale, sigmoid and tanh, with named inputs and Bank values. FormulaScan carries its hidden state through a bounded sequence. The same declaration is executed in PyTorch and native JAX.

Read the runnable program ↓
xₜsequence input
hₜ₋₁incoming carry
Bank operandsgain · retention
σgate
tanhcandidate value
hₜnext carry
Σ haccumulated carry
Shared declaration

15 typed instructions. One bounded recurrence, shared by PyTorch and native JAX.

Grouped view of a public FormulaScan; recorded execution, not browser inference.

THE COMPUTATIONAL BASIS

Build structures from explicit primitives.

Formula structures remain ordinary typed programs. The graph layer names the resources and relations that connect them.

FormulaFabric

Typed SSA execution

Contraction, scaling, reduction, nonlinear maps, lookup, indexing and masked normalization. Attention and nonlinearities can be expressed through these atoms with explicit Bank operands.

Implementation contract ↗

ProgramGraph

Resources and named ports

Declare stages, resource publications and dependencies. Routes, joins and bounded loops expose the structure of more complex computation through named contracts.

Implementation contract ↗

Learned connections

Data and credit connectivity

Connection parameters participate in the chosen objective. A CreditBoundary preserves forward data while controlling the credit that crosses that particular connection.

Implementation contract ↗

Forward plasticity

Proposals, re-execution and commit

A branch-local successor Bank can influence a producer when it re-executes. The stopped winner’s proposal can be committed; differentiable cross-event work adopts functional state explicitly.

Implementation contract ↗

LEARNING ACROSS A GRAPH

Define where credit travels.

The forward graph and learning connectivity have separate contracts. Local pullbacks, graph regions and explicit parameter ownership let the supported profile organize learning without hiding it inside an opaque module.

Learning-boundary guide →

Local credit. Owned optimizer state.

Registered graph nodes can expose a local VJP. A fixed graph credit plan traverses the declared publication order and accumulates shared parameter cotangents under stable identifiers.

Optimizer domains group parameter owners and retain their own moments and clocks. Structure decisions can be committed at a completed training window, with state migration handled by the declared plan.

Advanced graph construction, search and some mechanisms retain explicit alpha lifecycles. The public guides distinguish fixed-graph execution from broader dynamic search and throughput claims.

APPLICATION BINDINGS

Bring the program into your model.

Choose a native program, configured model attachment or supported pretrained recipe. The application supplies its data and objective.

Python / configured graph host
layer = arti.ARTILayer(
    graph=graph,
    graph_program_id="forward",
    graph_input_resource_id="input",
    graph_output_resource_id="output",
)
model = arti.ARTI.attach(model, layer, layers="model.layers.*")
session = model.arti.trainer(objective="model_loss")

Excerpt from the public integration contract: the caller supplies the configured graph and compatible host boundary. An empty ARTILayer is exactly identity.

EXECUTION CONTINUES AS AN ASSET

Keep the declaration with the work.

Supported assets retain tensor values, graph/component metadata and content-addressed provenance. Host weights and custom reconstruction code remain explicit dependencies of the chosen profile.