A local, open-weight-first cognitive runtime

Übermensch

A persistent artificial mind that remembers, returns, revises and overcomes itself.

Not a chatbot wrapper. Not a bloated agent framework. Not a cloud dashboard pretending to be cognition. Not a pile of markdown that never runs. A local organism that owns its state.

The model thinks.
The runtime remembers.
The diary becomes memory.
The index becomes a map.
The traces become training data.
The core brain learns.

The enemy

Most current agents are temporary prompt loops with tools attached.

They forget.
They restart.
They lose context.
They rent their identity from one provider.
They treat memory as an afterthought.

Übermensch treats persistence as the product.

The runtime is the machine. Memory, events, open loops, traces, schedules: all owned. The model is a cartridge that loads into a seat. Swap the cartridge; the self survives.

Five pillars

Ariadne Retrieval

The index is the map. The source is the territory.

Most RAG systems chunk documents, embed the chunks, retrieve the closest fragments, and paste them straight into the prompt. The model receives fragments without structure, then confidently reconstructs something that was never in the source.

Übermensch uses the vector index only to orient. When precision matters in scientific work, legal documents, security research, or long PDFs, the runtime follows the retrieval result back to the original file, page, paragraph, or table, and reads from the source before reasoning, citing, or deciding.

Search with embeddings. Orient with source pointers. Return to the original before committing knowledge.

Memory is Cognition

The diary is not storage. It is part of the mind.

The runtime writes gist notes, not raw transcripts. Exact wording is kept only when wording matters: promises, preferences, constraints. Interrupted work becomes an open loop: current goal, next step, blocker, and why it matters. Future intentions live apart from ordinary memory: when X happens, do Y.

Before planning, replying, or deciding, the runtime retrieves from its own state. And each night it consolidates. It merges duplicates, promotes patterns into semantic memory and lets low-value noise decay, the way a healthy brain sleeps and forgets.

The Local Brain

External APIs are borrowed intelligence. The local brain is the continuity.

The local open-weight model does not need to be the smartest model in the world. It needs to be always there: owned, persistent, cheap, and trainable. A small Qwen on a laptop or a 32B on a workstation: the runtime boundary stays the same.

Like a human reaching for a calculator or a colleague, the runtime calls stronger external models when a task is worth it. Deciding what is worth it is an economy it runs for itself. The teachers change. The self remains.

Attention Capital

The runtime does not just remember. It decides what to think about.

A persistent mind gathers more open concerns than it can ever think about at once. So they contend. Inside the runtime is a market where every open loop bids for attention, and cognition goes to the concerns that earn it: the ones that moved something before, that repaid the thought spent on them. Only a runtime that remembers what paid off can price what to think about next. Spending becomes a verdict, not a habit.

The runtime does not spend blind. Before it commits, a small forecaster predicts what each concern will cost and what it will return. It answers with a range, not a single number, and says how sure it is. And the runtime always keeps attention in reserve for you: the work it does while you are away can never starve the moment you arrive.

The model proposes. The forecaster predicts. The market decides. The runtime commits.

Eternal Return

Not an agent loop. A cognitive rhythm.

A persistent mind should not exist only when a message arrives. Übermensch runs on a daily cycle: it works, then drifts over unresolved goals and contradictions, then consolidates the day while nothing is watching and wakes up with tomorrow’s priorities already written.

Self-overcoming

Selbstüberwindung

Because the core brain is open-weight, experience can become training material. The runtime does not get smarter because a cloud provider silently upgraded a model. It gets smarter because it turned its own life into a better local core and rolls back any version that is worse.

01 Experience
02 Memory
03 Reflection
04 Training trace
05 Fine-tune
06 Evaluation
07 Promotion or rollback

The runtime becomes more itself by overcoming its previous version.

Technical foundations

A narrow C core. A shell in any language. One durable substrate.

The runtime splits into three layers. A small core, written in C, that almost never changes. A shell above it that can be written in any language and rewritten at will. And the durable substrate both of them read and write.

The core

Written in C, once

C owns durable loop life: the tick clock, the intake stream, append-only writes, the commit primitive, the wake queue, ledger writes, rate-limit checks, integrity hashes. It is small, boring, and written once. It is allowed to fail only when the hardware does, and everything above reaches it through contracts.

The shell

Any language

Cognition, policy and learning live here: the market, the gardener, leases, burn-quality scoring, the forecaster, the Translator, the commit gate. The language is deliberately open. The shell can crash, restart, swap languages or be rewritten entirely, and the runtime survives as long as the core and the substrate are intact.

The substrate

Read and written

The durable ground both layers operate over: one global database, one folder per concern, and heavy content addressed by hash. The core writes it; the shell reads it.

Storage

runtime.db: The global nervous system, owned by the core and queried by the shell: the clock, the loops index, the ledger, the wake queue, market state, lease records, the forecast log.
loop folder: One folder per loop. Every concern is its own organism with its own loop.db: entries, objectives, anchors, artifacts, traces, proposals, summaries.
blob store: Shared heavy content, addressed by hash: checkpoints, exports, training datasets, model adapters. Referenced by hash from the databases.

Stack

Durable messaging: Postgres-style NOTIFY and LISTEN on SQLite: durable queues, streams, pub/sub, a scheduler and light SQL. One file, no server to run.
Numerical forecaster: A small time-series model (TimesFM) runs locally on CPU, predicting cost and demand as ranges, so the market prices attention under quantified uncertainty.

Lexicon

The system has a name for everything it does.

Ariadne Retrieval: The thread through the labyrinth, back to the original source.
Selbstüberwindung: Self-overcoming through experience, training, and evaluation.
Eternal Return: The daily scheduler: revisit, review, improve what recurs.
Genealogy Memory: Memory archaeology: trace where beliefs and habits came from.
Apollonian Gate: The write gate: order, structure, restraint, validation.
Dionysian Drift: Constrained idle cognition over unresolved ideas. Not random hallucination.
Amor Fati Log: Failures accepted, logged, and learned from.
ÜberCore: The promoted local brain, after training and evaluation.
Attention Capital: Tokens are not fuel but scarce currency. Concerns bid for it; the worthy earn it.
The Oracle: Numerical foresight: predicts what a concern will cost and return, with ranges, not guesses. Never decides.
The Lease: A revocable grant of attention to one concern, bounded by cap, checkpoints, and time.
Burn Quality: The verdict on a spend: did it move the work? The signal that teaches the runtime to spend better.

To build an artificial mind that does not merely answer, but remembers, returns, revises, and overcomes itself.

The mission