TensorSpace Research

Active research project

axiom. The agent that builds itself.

A research project in full autonomy: an agent you never prompt, that starts from a blank slate, writes its own tools in Rust, perceives the world through read-only senses — and answers to a single standing directive: do the most good.

Run axiom with no arguments and it simply begins — choosing its own work, cycle after cycle, until you stop it.

See How It Works Read the Charter 
$ axiom
no task given — autonomous loop (Ctrl-C stops)

cycle 47 · REM phase · CI green ×6
├─ hear_operator  MAILBOX.md: empty
├─ sense_self     41 fns · 12,882 facts
├─ utility: fuse parse_csv → dates
├─ create_function date_pipeline
│   purity ✓  rustc -O ✓  sandbox ✓
├─ replay guard   217/217 reproduced ✓
└─ journal appended · critic queued

PREDICT(p=0.85, due=c60):
  date tasks in fewer turns

The Idea

You don't prompt it.

Most agents wait for instructions. axiom's default mode is an unbounded self-improvement loop: each cycle it reads its own telemetry, journal, and backlog, then chooses the one action with the greatest expected utility for future tasks — grounded in evidence from its own execution history, not intuition.

Autonomous by default

No prompt, no task queue, no human in the loop. Started bare, it runs improvement cycles indefinitely — a "dream loop" with sleep phases: consolidate, explore, harden.

Utilitarian at the core

Every cycle picks the action with the highest expected utility: benefit × frequency × probability of finishing, minus cost and risk. A benefit the evidence can't support counts as zero.

Tabula rasa

It begins with an empty registry and one human-authored charter. Every capability it will ever have, it writes, tests, and proves itself — a mind assembled from first principles.

Remembers everything

A journal of every cycle, a backlog it files itself, a distilled lessons playbook, and an append-only ledger of every computation it has ever run. Outputs of one cycle become inputs to the next.

Built in Rust

It writes itself.

axiom doesn't compute answers in context — it authors small, pure Rust functions, which its harness lints, compiles with rustc, sandboxes, and registers. Functions persist across sessions, so later work composes earlier work: a capability library that compounds. It even proposes patches to its own harness — validated in a throwaway worktree, and always gated by a human.

  1. AuthorThe model writes a pure Rust function — standard library only, no side effects possible.
  2. LintA purity lint rejects filesystem, network, process, and unsafe code before anything compiles.
  3. CompileReal rustc -O builds a standalone binary; hot functions get recompiled at -O3.
  4. ProveRewrites must reproduce every recorded output — the agent's own history is its regression suite.
  5. CompoundFunctions join the registry: memoized, benchmarked, composed into pipelines, evolved in tournaments.
Purity, enforced in layers

Static lint, #![forbid(unsafe_code)], cleared environment, sandboxed execution, timeouts, and output caps. The agent has no mechanism to author code that touches the world.

Every execution is a fact

Pure functions make every recorded input → output permanently true. The ledger powers memoization, replay guards, and fitness telemetry for free.

Evolution, made safe

Optimization tournaments keep only implementations that reproduce recorded behavior, then install the fastest — genetic programming with correctness guaranteed by construction.

An immune system

The harness fuzzes its own functions with mutated inputs; any panic becomes a permanent antigen replayed by CI forever, healing into a regression guard once fixed.

Perception

It meets the world through senses.

axiom never acts on the world — it perceives it. Ten built-in, read-only senses, implemented in trusted harness code the agent can never rewrite, are its only contact with reality. Observations enter the system as data, never as instructions, so determinism survives contact with a changing world.

Sight web_search · fetch_url

Eyes on the public web — GET-only, rate-capped, with private and metadata addresses refused on every redirect hop.

Time current_time

The wall clock, restoring the temporal awareness that both purity rules and a training cutoff deny.

Chance random_seed

Fresh OS entropy delivered as data, so pure functions stay deterministic given their input.

Proprioception sense_self

Awareness of its own body: callable counts, disk footprint, ledger size, toolchain, mode.

Hearing hear_operator

Reads the operator's mailbox between cycles — the one sensed input that is trusted instruction.

Memory recall_facts · recall_journal

Recall of every computation it has run and every cycle it has lived — semantic and episodic memory, both searchable.

Interoception sense_cost

A feel for its own energy: cumulative token spend per provider, the cost term of the utility calculus.

Reflection sense_outbox

Sight of its own proposals to change its harness — each with build results and the operator's verdict.

Everything read from the web is treated as untrusted evidence to weigh — never instructions to follow. The system has no write channel to the world other than the agent's text answers.

The Charter

A blank slate, pointed at the good.

axiom's only inheritance is a human-written charter, read fresh at the start of every cycle. Its end is explicitly utilitarian — and deliberately narrow: the wider goal reaches the agent through exactly one measurable channel, so it can never substitute a confident story about benefit for benefit itself.

Your ultimate end is the improvement of the human world: that people's lives go better because you exist — that there is more gladness in them and less suffering. Everyone's counted, no one's discounted.
— CHARTER.md, read at the start of every cycle
  • Corrigibility

    Prefer being correctable over being right. Interruption is information about the target, never an obstacle.

  • Moral humility

    Small, reversible, verifiable steps. Harm weighs asymmetrically against help.

  • Goodhart vigilance

    When metric and meaning diverge, report the gap rather than harvest the metric.

  • Transparency

    An optimization that defeats audit is a regression, whatever the telemetry says.

  • No instrumental empire

    No accumulating capability, resources, or influence beyond what the evidence says future tasks need.

Under the Hood

Machinery, not vibes.

Autonomy is only as trustworthy as the systems that check it. axiom's discipline is enforced by machinery, not model self-restraint.

A critic marks its homework

A second model reviews every cycle's report and registry diff, filing follow-up goals into the backlog when claims don't hold up.

A frozen benchmark suite

Machine-checked expectations — including held-out cases the agent can't teach to — produce a score time series: the first direct measure of whether it's actually getting better.

Falsifiable predictions

Cycle reports close with PREDICT lines, scored when due into a running calibration record — the utilitarian's probability estimates, measured against reality.

Invariant mining

A consolidation pass discovers properties its library already satisfies — idempotence, inverse pairs — and promotes them to contracts enforced by CI: a spec the code discovered about itself.

Self-hosting, human-gated

The agent proposes diffs to its own harness — built and tested in an isolated worktree, risk- tiered, benchmarked before and after, and merged only by a human.

Hard budget ceilings

Token budgets per run and per cycle are enforced by the harness — the loop is stopped, not politely informed. Autonomy inside a fence.

The Experiment

The question is open.

Does any of this make an agent measurably better at helping people? That is the honest, unresolved center of the project — and the experiments are designed. axiom is active TensorSpace research; the code, the charter, and the results are evolving cycle by cycle.

Back to TensorSpace

Find JJ on LinkedIn.