DEXRLUMUSMAXIMA.AI
Standalone desktop app · no cloud · no account
Deterministic · Recursive · Verifiable

DEXR

The local-first AI workspace that pairs deterministic execution with recursive agents — a complete environment to build, test and ship with confidence. Fully offline by default.

✉ Book early access Explore the architecture →
macOS · Windows · Linux — the only network allowed is HTTP to 127.0.0.1
dexr — project: workspace · deterministic mode
10:42:01▸ plandecomposed task → 6 bounded steps
10:42:02▸ executeagent-mesh · depth 3 · approval-gated tools
10:42:04▸ validaterules: 12/12 · policy check passed
10:42:05▸ repairattempt 1/4 → re-validate
10:42:07▸ capsulecapsule sealed
10:42:09✓ completebyte-for-byte match · result committed
100%
Offline by default
Same
Input → same output
0–4
Repair attempts / task
Byte
For-byte verified
Core principles

Built on four non-negotiables

Most AI tools ask you to trade control for capability. DEXR refuses that trade — every result is private, reproducible and provable.

01
⌂

Local-First

No cloud, no accounts, no telemetry. Your projects and files never leave the machine. DEXR works fully offline out of the box.

02
≣

Deterministic

The NeuroRoute engine uses deterministic routing and policy selection. Same input, same output — every run, on every machine.

03
↻

Recursive

Break a task down, execute within bounded depth, validate, repeat. A mesh of specialised agents self-corrects until the rules pass.

04
✓

Verifiable

Every build is quined and byte-compared against a canonical capsule. If it doesn't match, it isn't approved. Nothing to trust — everything to check.

System architecture

One deterministic core, many bounded agents

A desktop shell wraps a deterministic routing engine, a recursive agent mesh and a versioned file workspace — with an optional local model runtime that never touches the network.

🖥 Desktop UI
  • Project Explorer
  • Chat
  • Agent Monitor
  • Logs
  • Settings
🗂 Project Manager
  • Project init
  • File index
  • Workspace
  • Config
◇ Agent Mesh
  • Recursive agents
  • Specialised roles
  • Bounded depth
  • Tool approval
📁 File Workspace
  • VFS layer
  • Versioned files
  • Snapshots
  • Diffs
🧠 NeuroRoute Engine — Deterministic Core
  • Routing & scoring
  • Policy selection
  • Deterministic math
  • Native C engine
  • Memory: episodic · semantic · tool cache · routing bias
⚙ Deterministic Mode
  • No model / no network
  • Templates · rules · algorithms
◐ Local AI Runtime (optional)
  • Local LLM via HTTP 127.0.0.1
  • No external network
🔧 Tool System (approval-gated)
  • File ops · shell · git
  • Local search · custom tools
🛡 Validation & Repair Loop
  • Validate
  • If fail → repair (0–4 attempts)
  • Re-validate
  • Complete / abort
The only network connection DEXR will ever make is HTTP to 127.0.0.1 — loopback, for an optional local model runtime.
Recursive workflow

From request to committed result

Every task travels the same bounded, auditable path. If validation fails, DEXR repairs and re-validates — up to four times — before it ever calls a task done.

1

Input

You provide a task or request

2

Plan

Task analysed & decomposed

3

Execute

Agents run within bounded limits

4

Validate

Output checked against rules

5

Repair

Bounded retry · 0–4 attempts

6

Complete

Result committed & logged

Verification & quine

If it doesn't match, it isn't shipped

DEXR builds in a deterministic environment, hashes the output into a canonical capsule, then rebuilds from scratch and compares byte-for-byte. Approval is earned, not assumed.

01
Build packageDeterministic build environment
02
Canonical capsuleNormalised & hashed (SHA-256)
03
Rebuild generationsRebuilt in a clean, locked environment
04
Byte comparisonCompare byte-by-byte with the canonical
05
Canonical matchIf all match → verified & approved
canonical.capsule● VERIFIED
envdeterministic · locked
algoSHA-256
✓ byte-for-byte match — result approved
Quine AIO · Self-reproduction

An app that recreates itself

DEXR ships as a Quine AIO: the application carries a sealed capsule of its own source (DXRCAP01) and can reproduce its complete source tree into an empty directory — then prove the copy is exact, generation after generation.

gen0
→
gen1
→
gen2
root(gen0) = root(gen1) = root(gen2)
zero missing files · zero extra canonical files · zero changed bytes or modes
dexr — payload-quine commands
$ python3 main.py quine inspect
$ python3 main.py quine reproduce --output /tmp/dexr-gen1
$ python3 main.py quine verify --report FIXED_POINT_PROOF.json
▸ capsule DXRCAP01 valid · AST policy passed · tree sealed
✓ fixed point proven — root(gen0) == root(gen1) == root(gen2)

Sealed kernel

The reproduction kernel is statically verified before every run. An AST-enforced import allowlist (base64, hashlib, os, sys) forbids dynamic execution, subprocess creation, environment inspection and all network APIs. It writes only into an explicitly empty directory — and never imports or runs its output.

Isolated execution

Reproduction runs in Python isolated mode with a pinned deterministic environment (LC_ALL=C, TZ=UTC, NPROC=1, hash seed 0), stdin disconnected and output captured — plus network-namespace isolation via unshare -n where the host permits it.

Content-addressed promotion

Proven candidates land in a content-addressed registry with an atomic pointer move — the running source tree is never overwritten. Promotion requires the successful proof file and a candidate whose root matches all three proven generation roots.

Every canonical file is a SHA-256 Merkle leaf (DXR-MERKLE-SHA256-v1). Truncation, mutation, reordering or a mode change is a hard error.
Verified host Linux x86_64 Python 3.12.3 GCC 13.3.0 Tests 106 passed · 0 failed · 0 skipped
Roadmap

Shipped, next and on the horizon

DEXR follows one rule: nothing is called done until it has been verified. Here is exactly where the project stands today — including the parts that are not finished yet.

✓ Now — verified in the current release
  • Local-first desktop workspace — no account, no subscription, no cloud dependency
  • Deterministic NeuroRoute engine with bit-exact native and Python parity
  • Recursive agent mesh — bounded depth, tool caps, 0–4 repair attempts
  • Approval-gated tools confined to the selected workspace
  • Payload quine proven byte for byte: gen0 = gen1 = gen2
  • 17-gate release matrix, sanitizers, 11 deliberate tamper trials
  • Native engine cross-compiled for six platform targets
  • Linux x86_64 release candidate + full professional documentation
◐ Next — reaching your desktop
  • macOS build: Developer ID signing, notarization and a DMG installer
  • Windows build: installer plus code signing for SmartScreen trust
  • Linux distribution through Flathub and the Snap Store
  • Linux ARM64 runtime qualification on real hardware
  • Public documentation portal and downloadable release archives
  • Licensing and early-access delivery for private beta users
○ Later — planned, not in this build
  • Optional cloud model providers — strictly opt-in, off by default, never required
  • Team workflows: shareable project templates and reusable task recipes
  • Plugin interface for custom tools and validators
  • Expanded local model support and quantized runtime presets
  • A companion mobile client built on the existing native engine
  • Third-party security review of the sandbox and quine pipeline
DEXR is qualified as a Linux x86_64 release candidate in its recorded test environment. macOS, Windows, Android and iOS still require native runtime testing, code signing and store review — so they are listed as work in progress, not as shipped.
🔒

Your machine. Your model. Your data.

DEXR has no cloud to leak to. It runs offline, and the single exception is a loopback call to a local runtime you control:

HTTP → 127.0.0.1

Early access

Be first to run DEXR.

DEXR is in private beta. Book early access and we'll send you a build for your platform — no sign-up, no subscription, no data leaving your machine.

✉ Book early access
Private beta · macOS · Windows · Linux at launch · Read the documentation