Core mechanisms

ARTI exposes its main mechanisms both through arti.nn.Layer and as standalone modules.

ARTI’s mechanism map is broader than Recall: structural context (coord, phase, mask, visibility), latent dynamics, Recall and workspace (Half, Fold, Pulse), autoregressive interfaces (observer inverse and Membrane), integration and portability, and literal/runtime-vocabulary interfaces. Maturity is per surface: the supported 1.x core is Stable Candidate; observer, Membrane, and literal model integrations remain Alpha or experimental.

See Phase & rotating frames for active-participant versus observer-participant semantics, and Membrane visibility routing for the separate router, visibility, model-context, and user-emission planes.

Recall proposes latent traces

ARTILatentRecallField creates candidate corrections from hidden state, masks, and optional recall context. It does not impose an application schema.

Half applies survival pressure

Half is a salience-conditioned activation. Strong features pass close to one; weaker features fade smoothly instead of being cut off abruptly.

half = arti.nn.Half(threshold=1.0, base=0.5)
survived = half(delta)

Fold creates a fixed workspace

Fold maps [B, N, D] into [B, K, D] with differentiable soft assignments.

fold = arti.nn.Fold(k=16, dim=64)
workspace = fold(h, mask=mask)

Keep padding masks separate from salience values when padding should not rank slot importance.

Pulse composes the path

Pulse forms compact learned workspaces from overcomplete latent fragments, combining projection, optional Half survival, and Fold compaction.

pulse = arti.nn.Pulse(k=16, dim=64)
workspace = pulse(h, mask=mask)

assert workspace.shape == (h.shape[0], 16, 64)

Each mechanism can be trained, tested, and deployed independently.

UnFold changes layout while preserving original values

UnFold queries new values and places them with every original instance through a sample-conditioned hard layout. ARTI 1.7.0 retains call-time target_length, so one configured maximum capacity can serve different workspace lengths.

unfold = arti.nn.UnFold(dim=64, exposed=32)
layout = unfold(workspace, target_length=20)
assert layout.shape == (workspace.shape[0], 20, 64)

It is not the inverse of Fold. See UnFold for source-index diagnostics, canonical guides, masks, and capacity boundaries.

FusionPulse combines compact workspaces

FusionPulse remains an Alpha layer in 1.7.0 for joining several already compact Pulse workspaces and returning one fixed [B,K,D] result.

fusion = arti.nn.FusionPulse(k=8, dim=64)
combined, info = fusion.concat(whole, regions, details, return_info=True)

Its path is joint context → feature-wise salience → Half → shared UnFold. The optional info["structural_loss"] is a label-free training aid, not a task metric or an information-preservation guarantee. See FusionPulse and the real browser workspace inspection.

Why native Recall banks may be concatenated

RecallExpertPool.concatenate() joins the bank slot dimension: [K1,H] + [K2,H] → [K1+K2,H]. The resulting Recall field performs one retrieval softmax over the enlarged address space; it is not a mixture of already-produced outputs.

pool = arti.RecallExpertPool(recall_expert, base_model=model)
pool.load_expert("coding", "coding.recall.arti.st")
pool.load_expert("dialogue", "dialogue.recall.arti.st")
recall = pool.concatenate()
delta, bank_weights, gate, recognition = recall(h, mask)

Concatenation is allowed only for native ARTILatentRecallField experts whose non-bank state is identical: query, gate, external projection, and recognition operator must match. The pool rejects divergence rather than choosing one expert’s operators. Train concat-safe online experts with RecallTTTSession(..., trainable_parameters=("bank",)). If shared operators differ, keep experts separate and use an explicit named route or non-negative mixture weights instead.

Use case: complementary visual observations

The evolving VisualScan surface applies the same fixed-workspace idea to rigid visual sampling. Its default observation pattern records four low-resolution frames at (0, 0), (0, 0.5), (0.5, 0), and (0.5, 0.5) pixel shifts. ARTI continuously inverse-registers those observations, forms position-carrying visual fragments, and lets Pulse compact them into K workspace slots.

import arti
import torch

config = arti.VisualScanConfig(
    low_size=(8, 8),
    scale=2,
    shifts=((0.0, 0.0), (0.0, 0.5), (0.5, 0.0), (0.5, 0.5)),
    patch_size=(4, 4),
    pulse_count=4,
)
scan = arti.VisualScan(config)

# frames: [B, scans, channels, height, width]
result = scan(frames, torch.tensor(config.shifts), return_info=True)
assert result.pulses.shape[:2] == (frames.shape[0], 4)

This is a physical sampling and latent-workspace contract—not a claim that Pulse reconstructs unknown image content. VisualScan is a public, evolving surface; arti.nn.Pulse itself belongs to the supported 1.x core.