Umwelt

What it is

Umwelt is a private research engine (private, withheld; not a public product) for software that has to act in a world it can only partly see. You describe the world once as a short structured file: the things you care about (a room, a stock, a place on a map), how they connect, and which readings feed each one. From then on you post observations, partial and sometimes conflicting, and it holds a running picture of that world in which every belief carries a confidence. It eases between sparse reports instead of snapping to the last number, and it can run the same dynamics forward to forecast.

It is not a chatbot, not a general AI, and not quantum hardware. The belief is held as a density matrix over a small graph of qubit clusters and evolved with the open-system equations physics already provides, computed with numpy on an ordinary machine. That choice is what gives it honest uncertainty by construction: a low-confidence reading provably moves a belief less than a high-confidence one, and a zero-confidence reading changes nothing.

Two habits set it apart. It never confuses its own actions with evidence: every action it takes is tagged, and learning is discounted by the action's echo, so it cannot learn that it caused what it then saw. And every decision starts in shadow mode: it decides, logs what it would have done, and dispatches nothing until that output is promoted.

The engine carries no domain words. A lint in its own test suite fails the build if one appears, which is why the same code sits under a home (Penduline), a war campaign (Verdance’s Ashes), a neighborhood storefront (Terrarium Store), a stock sentiment tracker (umwelt-market), a story-game kernel (Septacrypt) and the task desk that feeds this site (Semantica). This site’s rule that an unmeasured value reads dark, never zero, is Umwelt’s rule first: its Frame export is the file format this page renders.

How it works

• A world is a file: nodes in a tree, each with the roles it tracks; bridges that couple neighbours; bindings that map each signal onto a node and role with a confidence; outputs, the decisions, shadow by default; drivers, the clocks.
• Observations go to an append-only log before they are processed. The log is the truth and a snapshot is a cache: boot is snapshot plus replay, and a test pins that the daemon adds nothing and loses nothing.
• A sensor is a forecast at horizon zero. Forecasting is the same dynamics run forward with no new input.
• Sources that disagree are fused by a learned trust web, initialised so that turning it on changes nothing until it has evidence. With a referee present, a corrupted source is isolated instead of dragging the whole picture.
• Every learnable parameter lives on a tracked fiber, so a frozen field produces an empty diff. “This did not train on you” is a checkable property, not a promise.
• The default update is a two-line confidence blend. The full quantum filter is implemented, was measured against the blend on real data, lost, and ships switched off with the result in the ledger.

What runs

• the engine service: a supervisor on one port with one worker process per world, routes for health, events, state, beliefs, recommendations, nameplates, a confession, a glass door and snapshots, a Docker image, and a playground page.
• umweltctl: the operating loop from a terminal. Create a world, check its health, push readings, read beliefs and recommendations, take a snapshot.
• umwelt-forge, experimental: an embedded coding agent writes the world file from a plain description, and a deterministic gate refuses to register any world whose declared inputs do not drive the model.
• Fourteen example worlds, from a fog-of-war grid to a self-model that forecasts itself. The grid and the fog corridor run in CI; the game and market worlds replay real data.

What exists today

Version 0.1.0, numpy as the only dependency, Python 3.10 and 3.12 in CI. Counted on 21 October 2026: 97 test files and 735 test functions; 15 named proof files, 10 of them in the default gate, each printing one result. Among them: a blank engine boots a synthetic world it has never seen and comprehends a day of it; a Frame export leaves the belief’s hash untouched; a corrupted source is isolated when a referee exists.

The claims ledger sorts every claim into pinned by test, measured on held data, designed with evaluation owed, and denied by its own experiment. The denied rows stay in, with their numbers.

The source is private; a walkthrough is available on request. One daemon runs on a private machine with no public endpoint.

Not done

No live deployment yet makes a consequential decision through the geometric-phase gate; that mechanism is pinned on replayed game data only.

The trust web matches last-wins on day one; the live comparison where it earns its keep is owed. On the market data it did not isolate a corrupted feed, and the ledger says why.

Real-data effect sizes for the self-tagging mechanism are still owed.

The world-authoring agent’s quality on real descriptions is unmeasured; only its safety gate is pinned.

Single-tenant: you run it yourself, locally or in your own infrastructure. There is no hosted product.

Next

One foreign world end to end with an independent check: Verdance’s Ashes first, Penduline’s Home Assistant bridge second.