Install

The source tree is versioned for NEOTH 1.0.0, but no v1.0.0 release or crates.io package exists yet. The current working install path is the source checkout below. The bootstrap commands become valid only after the first compatible signed release is published; cargo install neoth --locked --features release-desktop becomes valid only after the ordered SDK + core crates.io publication completes. Default source builds require Rust 1.91; the Matrix-enabled release-desktop and release-server bundles require Rust 1.93. Until that first signed tag and publication, the neothd Rust-library API is not frozen; daemon-internal modules may still be narrowed or removed. The separately versioned neoth-plugin-sdk is the intended external extension boundary. The v1 API compatibility promise begins with the published release.

Current install (source checkout):

git clone https://github.com/The-Geek-Freaks/NEOTH
cd NEOTH
NEOTH_SRC_DIR="$PWD" bash scripts/install.sh
neoth

The all-components source installer needs Node.js 22.16+ to compile the Keet standalone. Signed desktop archives bundle it and need no Node.js.

After the first signed release, one-command install (Linux/macOS):

curl -fsSL https://raw.githubusercontent.com/The-Geek-Freaks/NEOTH/main/SRC/install.sh | bash
export PATH="$HOME/.local/bin:$PATH" # profile wiring applies automatically to new shells
neoth

The binary installer always verifies SHA-256 plus release authenticity. It uses an installed minisign with the pinned public key, an installed cosign, or downloads a temporary Cosign verifier whose platform SHA-256 is pinned to an immutable official Sigstore source commit. A clean machine therefore needs no preinstalled verifier. A downloaded verifier with the wrong digest is never executed; NEOTH_ALLOW_UNVERIFIED_RECOVERY=1 applies only when the verifier cannot be downloaded and the archive was authenticated out of band.

Desktop archives contain neoth, the neothd compatibility launcher, the separate neothd-gui binary consumed by bare neoth and neoth gui, neoth-migrate, and neoth-relay, plus the zero-dependency neoth-keet-bridge standalone. They also carry a release-bound Graphify map of the exact tagged source tree; NEOTH verifies its source HEAD, version, closed file set, and payload hash before using it. Graphify and Python are build-time release inputs, not user dependencies. Only the explicitly headless musl server archive omits the GUI and the glibc-linked Keet companion.

Current release-truth note (2026-08-08): the source-tree Graphify runtime hardening is still an open v1.0 Gold integration gate, not a released-artifact claim. The pinned package is graphifyy==0.8.41, but its isolated module entry is python -I -m graphify. Packaged, verified self-knowledge remains readable and queryable on every supported platform without Python. Generation on Unix/macOS currently fails closed while NEOTH completes a bundled unescapable containment backend; it will not fall back to an escapable process group. See the authoritative Gold roadmap for the remaining Graphify, SelfMap, provider-cap and exact-head acceptance gates. The future crates.io package installs only the neoth/neothd core package; use a release archive or source checkout for the companion executables.

After the first signed release, Windows users can download and double-click the signed NEOTH-1.0.0-x64-Setup.exe (or ARM64 variant) on the Releases page. The zero-prompt PowerShell alternative is:

irm https://raw.githubusercontent.com/The-Geek-Freaks/NEOTH/main/SRC/install.ps1 | iex
neoth

Bare neoth is the product launcher. On the first display-bearing launch it shows one accessible Graphical setup / Command-line setup choice and stores the answer in the active NEOTH_HOME; later launches go straight to that surface. SSH, CI, Windows Session 0, and other headless sessions stay in the CLI. Automation can choose explicitly with NEOTH_INTERFACE=gui or NEOTH_INTERFACE=cli (exact lowercase values). Switch at any time with neoth gui, neoth interface set cli, or Open CLI in the GUI.

Then run the health check:

neoth doctor
neoth doctor --explain "freedom.yaml"

The wizard asks normal questions: who you are, what NEOTH may remember, whether you want local-only or cloud providers, which channels to connect, and how much autonomy NEOTH gets. YAML is optional. The happy path is a GUI path.

Demo Loops

Why NEOTH

Most AI tools are brilliant strangers. They can answer one prompt, but they do not really know you, cannot prove what they remembered, and quietly move the trust boundary to someone else's backend.

NEOTH is built around a different promise:

The AI should be loyal to the user, not to a platform.

That means:

For Normal Users And Pros

NEOTH is deliberately not only for developers. The core product is a buddy that can be used by a normal person, while still staying deep enough for a senior operator.

What NEOTH Does

Privacy

NEOTH is local-first and fail-closed by design.

Local-only mode is a first-class path:

neoth preset activate fully-local
neoth preset apply fully-local
neoth doctor
neoth privacy audit --last 30d

Read the full privacy model in docs/privacy.md.

Security-research skills ship enabled by default. NEOTH bundles three dual-use registers — lowkey_base (authorised security research / defensive analysis), raskal (authorised red-team / offensive-tooling), and archon (meta-reasoning orchestrator). They are operator-authorisation-scoped — they refuse mass-harm, untargeted destruction, and out-of-scope targets — and ship enabled so an authorised pentester gets working tooling instead of refusals. Don't want them? Disable any subset in freedom.yaml:

skills:
  disabled:
    - raskal
    - archon

(Or suppress all skill injection for benchmark/eval runs with skills.disabled_for_eval_sessions: true.)

Why it holds up

The differentiators are mechanisms you can inspect, not slogans.

Governed sensitive paths emit typed events into an append-only, HMAC-chained WAL — and you get the commands to prove what was recorded: neoth verify (chain integrity), neoth wal show --type <event> (every frame of one kind), neoth privacy audit --last 30d (recorded provider/channel/privacy activity). Audit coverage and explicit best-effort or log-only exceptions are listed in the threat model; chain verification proves that recorded frames were not altered, not that every possible side effect emitted a frame.

A WASM plugin built against the versioned neoth-plugin-sdk guest ABI exports neoth_abi_version() -> i32 plus neoth_run() -> i32; the daemon checks ABI v1 before execution. It can only use the hostcalls its manifest declared and you approved at neoth plugin enable. That approval is bound to the exact permission, canonical manifest digest, and WASM digest: any later semantic manifest, capability, or binary change cannot load on the next daemon start until you explicitly re-enable it. The running daemon keeps only its already-validated immutable module, approval, and manifest-derived fuel/memory-limit snapshot. A call above the approved level is refused fail-closed at runtime and recorded as a 0xC7 PLUGIN_CAP_DENIED audit frame — visible in neoth wal show --type plugin_cap_denied, never silent.

Skills have a deliberately different boundary. They are prompt/data packages, not executable WASM modules, so a Skill install receipt proves exact bytes and transactional publication but is not runtime authority. An external installed Skill is routable only through a versioned authenticated authority record and Current Anchor that exactly bind package generation/incarnation, terminal receipt, provenance, enabled state, effective tool scope, delegation, model, source, and policy. A missing, stale, revoked, edited, or mismatched binding falls back to bundled-only routing. Positive and negative Skill mutations validate the authority-admitted post-mutation catalogue under the package lock before filesystem, configuration or authority publication. Chat, channels, CLI, GUI and Buddy consume the same typed route decision; inspect it with neoth skills --check-routing or select explicitly with neoth chat --skill <id> "...". Subprocess MCP reconnect/poisoning, broader Buddy parity and exact-head platform gates remain open under the Gold roadmap. NEOTH does not market the WASM sandbox as protection for Skills.

Crossing a trust boundary — cloud call, profile-to-cloud extract, channel egress, plugin capability, autonomy raise — is denied by default until you grant it once, on purpose. Both the grant and the refusal are logged.

Any model id passes through the provider layer with no hardcoded whitelist; the managed CLIs (claude-cli / codex / antigravity) self-update and the model catalog is discovered at runtime — so a new model ships and NEOTH already routes to it, no source patch.

Coding Buddy

NEOTH is not a coding toy bolted onto a chat app. The coding path is designed for visible planning, reviewable execution, and memory that improves future work.

Operator commands:

neoth code "plan the auth refactor"
neoth kanban watch
neoth code check
neoth recall "why did we choose this storage layout?"

Brain And Memory

NEOTH uses role separation because a loyal assistant should not treat every task as one giant prompt.

The point is not mystical branding. The point is operational separation: fast tasks stay fast, serious tasks get more scrutiny, and durable memory gets evidence instead of vibes.

Each path binds to its own provider — Anthropic on the left, a local model on the right, OpenRouter as arbiter, any mix you want — and hard questions go to a council: the paths argue, dissent is recorded, and the runtime tracks which path wins which kind of argument over time and reweights routing accordingly.

neoth hemispheres set --role right --provider local_ouro
neoth council voices
neoth ecology winner-chain   # who has been winning the arguments, and why

Facts you never want the model to overwrite live in a separate register: neoth groundtruth add pins them immutably, and NEOTH flags contradictions across sessions for you to resolve instead of silently picking a side.

Babel-Index: It Predicts Its Own Collapse

Agent systems fail in recognizable shapes — retry storms, agent loops, context death spirals. Most frameworks let you find them in the post-mortem. NEOTH watches its own WAL event stream, scores every rolling window with seven collapse variables (coupling, convergence, pressure, agent density, throughput vs. diversity and redundancy buffers), and warns you before the failure. The failure definitions are deterministic and pre-registered; the predictor self-calibrates against its own misses and reports a Brier score, so the accuracy claim is measurable instead of asserted.

neoth babel status      # threshold, calibration, latest scores
neoth babel windows     # the actual measurements, window by window

K_d uses the content-free K_d_v0 response histogram by default. Operators can select a configured local embedding checkpoint with babel.k_d_embedding_model; the central provider-completion boundary covers streaming and non-streaming successes, while Incognito calls never enter the feed. Optional memory_signals and skill_signals add versioned, content-free posture counters for contradictions, true recall misses, and the final skill-routing outcome. They are off by default and never silently rewrite the seven score variables.

There is a bigger bet underneath: the collapse model comes from delta-kosmologie, an open framework asking whether one scalar family predicts collapse across complex systems in general. Opting in (off by default, consent- and autonomy-gated) federates anonymised, Ed25519-signed, content-free window records into the shared falsification pool — making NEOTH the first production instrument of an open research program, with docs/babel-index.md spelling out every rule.

Shipped, Easy To Miss

Small commands that quietly carry a lot of the product. All of these work today:

Comparison

Different projects optimize for different jobs. NEOTH's bet is the harder overlap: a DAU-friendly buddy, serious coding partner, local-first memory system, private mesh, and inspectable operator runtime in one product.

Five things you will not find documented in any of the compared projects — each with the command that proves it on your machine:

Competitor columns were re-verified against upstream releases on 2026-07-03 (Hermes v0.18.0, OpenClaw v2026.6.11, OpenHuman v0.58.7) — where a competitor caught up, the table says so.

NEOTH is pre-1.0, so this table is honest about what is not finished. Private mesh now has per-peer durable cursors, authenticated content-bound ACKs, byte-exact restart replay, transactional receiver materialization, deterministic conflict records, and canonical memory/ground-truth snapshots over peeroxide and optional Iroh carriers; see the durable sync contract. The WASM plugin capability sandbox (V10-04) ships in the native desktop release binaries and is exercised by tests, but it is feature-gated (wasm-plugin-host) — source builds opt in, and only the headless static musl server archive omits it. Native GNU Linux x64 and ARM64 desktop archives both include the GUI, Keet companion, WASM host and other release-desktop capabilities. Built for DAUs and pros is the explicit design goal, not a finished claim — it is the hard bet NEOTH is making, and the single thing most worth holding it accountable to. Everything marked Yes is implemented and exercised by tests; the live status of every line item is in PLAN/PROGRESS_v1_0.md.

Native GNU Linux, macOS and Windows desktop releases include both Peeroxide and Iroh; the static headless musl server includes Peeroxide only. Cluster settings are submitted as one exact GUI/CLI transaction, including optional stdin-only passphrase handling. Enabled carrier changes are not hot-switched today: the receipt reports restart_required: true, and the supervised daemon must be restarted before transport, mDNS or gossip behavior is considered active. A disabled cluster with no running daemon is already inert and correctly reports restart_required: false. A retry cannot erase a real pending state; cluster status reports an active carrier only after the daemon acknowledges successful startup for both the exact public snapshot and its owner-private identity binding.

Read the detailed migration pages:

• NEOTH vs OpenHuman
• NEOTH vs OpenClaw
• NEOTH vs Hermes Agent

Doctor

Setup errors should not feel like archaeology.

neoth doctor
neoth doctor --list-checks
neoth doctor --explain "channels wiring"
neoth doctor --explain "model caches"
neoth doctor --output json

neoth doctor checks config, credentials, profile database, WAL, HMAC key, disk space, local model caches, channel wiring, Node-backed providers, tmux for Claude CLI, plugin host state, provider flapping, usage caps, cluster registry, and mDNS announcer behavior. Warn/fail output points to the exact --explain runbook so beginners get plain fixes and pros get scriptable diagnostics.

Docs

Release Shape

NEOTH 1.0 is for one operator first: your machine, your memory, your private tools, your approved network. It is not a hosted SaaS account, not a team multi-tenant product, and not a black-box model router.

What works and what intentionally stays out of 1.0 is tracked in docs/release-notes-v1.0.md.

Contributing

Small, focused PRs are welcome. Read CONTRIBUTING.md, run the checks, and keep the product promise intact: simple for normal users, serious for operators, loyal to the user.

License

NEOTH is dual-licensed under MIT OR Apache-2.0, at your option — see LICENSE-MIT and LICENSE-APACHE. Third-party notices: THIRD_PARTY_LICENSES.