TensorCode Docs

tensorcode / developer documentation

Written steps and learned steps, in one traced program.

Every step is an operation with one calling convention, op(value, *, context=None): written ones (subclass Operation) and learned ones that own their weights (ops.vec, ops.text). trace() records which operation produced which value, supervise() attaches a sourced target to any of them, and a Trainer replays the supported local tensor paths and updates only the parameters on them.

Complete tools (Investigator, Planner, Chatbot and more) own their encoders, workspace and decoders, and keep evidence, hypotheses and outcomes separate. Everything saves as data-only artifacts with save_pretrained / from_pretrained, offline or from the Hugging Face Hub. Importing the core package loads no ML framework and makes no network calls.

InstallArchitecture overview

Pick an implementation

Both implement the same public contracts: operations, tools, sessions, tracing, experience and artifacts. The Python package is the reference. The TypeScript port matches it and reads and writes the same files, so a model trained in one language loads in the other. What differs.

Python

tensorcode 0.4.0a5

The reference implementation, on PyTorch. Python 3.11 or newer; install from PyPI with pip.

python -m pip install 'tensorcode[tools]'
from tensorcode.program import compile, int32

choose = compile("def choose(a): return 10 if a > 4 else 12",
                 inputs={"a": int32(min=-128, max=127)})
assert choose.run({"a": 5}) == {"result": 10}
checked = choose.verify(lambda a: 10 if a > 4 else 12)
assert checked["passed"] and checked["cases"] == 256
All Python docs →

TypeScript

tensorcode 0.4.0-alpha.5

The port for Node.js 20.16 or newer, with its own autograd core, source compiler and portable program runtime; install from npm.

npm install tensorcode
import { compile, int32 } from 'tensorcode/program';

const choose = compile((a: number) => a > 4 ? 10 : 12, {
  inputs: { a: int32({ min: -128, max: 127 }) },
  semantics: 'exact',
});
console.log(choose.run({ a: 5 })); // { result: 10 }
console.log(choose.verify()); // passed: true, cases: 256, exhaustive: true
All TypeScript docs →

How the pieces fit

Operations are the callable units. Tools compose them and own every parameter. Sessions are runtime state, never saved into model weights. Experience is the only path from runtime back into training.

TensorCode architecture Operations (vec, text, graph) are composed into tools (Chatbot, Investigator, Planner, Decision, Scene). A tool owns its model parameters and creates sessions that hold sourced evidence, revisions and memory. Sessions emit receipts and experience records; the trainer fits the tool's parameters from experience; artifacts are saved with save_pretrained and restored with from_pretrained, locally or from the Hugging Face Hub. OPERATIONS ops.vecencode, decode, classify, retrieve ops.textmessages, classify, decide, retrieve ops.graphsymbolic interfaces (stubs) TOOLS ChatbotInvestigatorPlannerDecisionScene own encoders, workspace, decodersconfigured from JSON RUNTIME Sessionssourced evidenceimmutable revisionsepisodic memory Receiptscandidates + sourcessupport / contradictionabstentions PERSISTENCE Artifactssave_pretrainedfrom_pretrainedlocal or HF Hub Experiencereviewed targetsaction outcomessource provenance from_pretrained restores exact weights and configuration training.Trainer.from_tool(model)capture → save experience → fit → checkpoint updates parameters

Core concepts

The vocabulary the guides use.

Operation
A callable operation(value, *, context=None). Learned operations take JSON configuration and own their weights; weightless ones are pure transforms.
Tool
An owned model (Chatbot, Investigator, Planner, Decision, Scene) with public interaction contracts. Constructing one initializes weights and downloads nothing.
Evidence
Source-identified observations. Generated hypotheses are interpretations, never evidence; revisions keep what a source originally said.
Receipt
Per-candidate support / contradiction / unknown assessments per source, with provenance, truncation and abstention status.
Experience
Data-only training records: inputs, reviewed targets or observed outcomes, and who supplied them.
Artifact
tensorcode_config.json + model.safetensors + model card. Loading rejects incompatible artifacts instead of executing code.

Status and measured scope

Alpha. The APIs are pre-1.0 and change between releases. Published checkpoints are small, fixed-split experiments, and they do not yet establish a consistent benefit from the recurrent workspace or general cognitive competence. Model probabilities are uncalibrated and verifier approval is not truth. Read validation and scope before choosing a model.