NEOTH

Your private AI buddy. Loyal to you. Useful everywhere.

One memory. Three brain paths. Five memory tiers + your vault. Local-first by default.

NEOTH is the personal AI system for people who want a real assistant, not a forgetful chatbot. It remembers what you approve, helps in daily life, codes seriously, connects to your tools, runs on your own machine, and leaves proof for every sensitive decision.

Normal user? Open the GUI and talk — no YAML. · Pro? Every claim has a CLI command that proves it. · Skeptic? 15 minutes, proof on your own machine.

Install · Why NEOTH · Demos · DAUs + Pros · Privacy · Coding · Babel-Index · Comparison · Docs

Install

NEOTH is at the 1.0 release-candidate stage (current crate version
1.0.0-beta.4). It is not yet published to crates.io, so install from source
or the bootstrap script — cargo install neoth will land with the 1.0 release.

One-command install (Linux/macOS):

curl -fsSL https://raw.githubusercontent.com/The-Geek-Freaks/NEOTH/main/SRC/install.sh | bash
neoth gui

Windows (PowerShell):

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

From source:

git clone https://github.com/The-Geek-Freaks/NEOTH
cd NEOTH/SRC
cargo install --path neothd
cargo install --path neothd-gui
neoth 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

First run	Memory proof

Coding buddy	Privacy audit

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:

Principle	What it means in practice
Your memory	Profile facts, project context, decisions, and recall live in your NEOTH home.
Your consent	Sensitive profile changes, provider routes, plugins, and external actions are inspectable.
Your tools	CLI, GUI, chat channels, Obsidian, Paperless, email, calendar, n8n, local models, and private mesh.
Your proof	WAL-backed audit, evidence-linked profile facts, plugin capability logs, and privacy commands.
Your upgrade path	Starts simple, scales into a serious operator runtime without switching products.

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.

If you are a normal user	If you are a pro
Open the GUI and talk normally.	Use the CLI, local models, WAL, policies, plugins, and cluster commands.
Say "remember this" and approve what matters.	Inspect exact evidence, confidence, provider destination, and redaction state.
Connect Telegram, Slack, WhatsApp, Obsidian, Paperless, email, and calendar.	Script workflows, bind n8n, define hooks, use MCP, and review plugin capabilities.
Ask "what did we decide?" and get useful recall.	Run `neoth recall`, `neoth verify`, `neoth privacy audit`, `neoth plugin ledger`.
Let NEOTH explain setup problems in plain language.	Pipe `neoth doctor --output json` into CI or fleet checks.

What NEOTH Does

Area	1.0 target behavior
Buddy	Keeps a durable personal profile, remembers approved facts, adapts to your style, and asks before crossing trust boundaries.
Brain	Routes work through role-bound brain paths for fast answers, deeper reasoning, and verification.
Memory	Uses five durable memory tiers — episode, profile, ground truth, consolidated, long-term — plus your external vault (Obsidian/Paperless) ingested into them.
Daily life	Ingests Paperless documents, email, calendar, notes, files, images, audio, and video into reviewable memory.
Coding	Plans work, tracks tasks on a canvas/Kanban board, runs checks, learns repo context, and promotes reviewed decisions into memory.
Self-diagnosis	Scores its own event stream for collapse risk (Babel-Index): seven variables per rolling window, pre-registered failure labels, early warning before the agent loop — not after.
Self-reflection	Looks back on its own work — weekly topic recap plus opt-in daily and yearly summaries archived and written to Obsidian as daily notes / yearly summaries — runs an opt-in weekly Hacker News tech-currency scan that flags trending topics your skills don't cover, and proposes review-gated SkillOpt improvements to its own skills (never auto-applied).
Self-evolution	Dreams nightly (`neoth dream now`): clusters the week's episodes into themes and writes them to Obsidian. Proposes, council-reviews, and applies upgrades to its own skills with rollback (`neoth self-improve`). Notices its own behavioral patterns and proposes changes you approve or decline (`neoth self-dev`). Distills tool sequences you repeat into candidate skills (`neoth distill`).
Migration	Brings your history with you: `neoth-migrate` imports Claude Code / Codex / Gemini sessions as searchable memory; `neoth transfer export` moves whole memories between machines as X25519-encrypted, Ed25519-signed bundles.
Autonomy	Four operator-set levels (`neoth autonomy strict..full`) plus one-word `neoth sudomode`; the security floor never moves regardless of level; your own plain-YAML constitution is injected before every prompt (`neoth moral-core`).
Gateway	OpenAI-compatible endpoint (`/v1/chat/completions`): point Cursor, Aider, or Continue at NEOTH and every call gets your provider routing, council, and audit trail.
Loops	`neoth loop run "<goal>" --until "<criterion>"` — bounded autonomous iteration with L1-L3 budget ladders, full history in `neoth loop history`.
Recon	Authorized-engagement recon through gated `uncover` (exposed-host discovery) and `tlsx` (TLS/cert intel) shims — refused under Strict autonomy and audit-logged.
Automation	Runs small local cron jobs and bigger localhost n8n workflows through the same policy and audit layer.
Channels	Talks through GUI, CLI, Telegram, WhatsApp Business, Slack Socket Mode, Discord, and Keet-style private channels.
Private mesh	Pairs nodes over LAN/mDNS, Tailscale, Hysteria, and consent-gated cluster discovery.
Plugins	Loads skills and WASM plugins behind capability gates, signature checks, revocation, and hostcall audit.
Doctor	Explains broken setup, missing keys, model cache problems, channel wiring, disk issues, plugin state, provider flapping, and cluster discovery.

Privacy

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

Guarantee	How to verify
No silent profile extraction to cloud	`neoth privacy audit --last 30d` (recent provider calls + profile writes + channel egress)
No silent provider fallback	`neoth provider list` and `neoth wal show --type provider_fallback_attempted` (every 429 failover is a durable audit frame)
No ambient plugin power	`neoth plugin ledger` (capabilities used) and `neoth wal show --type plugin_cap_denied` (over-level calls refused at runtime)
No invisible memory mutation	`neoth profile pending` and `neoth profile show`
No unverifiable history	`neoth verify`
No accidental channel writes	approval policy plus WAL events for outbound actions

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.

Every sensitive action lands in an append-only, HMAC-chained WAL — and you get
the commands to prove what it did: neoth verify (chain integrity),
neoth wal show --type <event> (every frame of one kind), neoth privacy audit --last 30d
(what actually left the device).

NEOTH plugin capability gate — hostcalls are gated at runtime by the operator-granted level; over-level calls are refused and audited as a 0xC7 frame

A WASM plugin can only use the hostcalls its manifest declared and you approved at
neoth plugin enable; a call above that 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.

NEOTH fail-closed consent — boundary crossings are denied by default and proceed only on an explicit, persisted operator grant; both allow and deny are audited

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.

NEOTH model-version-agnostic provider layer — any model id passes through with no whitelist; CLIs self-update and the catalog is discovered at runtime

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.

Step	What NEOTH does
Plan	Turns a request into a scoped plan, risk list, and acceptance checks.
Map	Reads repo context, prior decisions, docs, issue state, and coding memory.
Track	Keeps backlog, todo, in-progress, review, done, blocked, and archived states visible.
Execute	Runs local checks, cargo/test/lint loops, and targeted implementation flows.
Review	Separates code generation from review, promotes only validated decisions into memory.
Improve	Learns repo conventions and recurring fixes without swallowing secrets or unapproved facts.

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.

System	Job
Left path	Fast, pragmatic help, routing, daily buddy work, small tasks.
Right path	Deeper reasoning, planning, alternatives, difficult code and architecture.
Corpus callosum	Arbitration, evidence collection, contradiction handling, consensus, escalation.
Five memory tiers + vault	Short recall, personal profile, ground truth anchors, consolidated facts, long-term knowledge — plus ingested external-vault context.

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

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:

Command	What you get
`neoth dream now`	Cluster recent episodes into themes, written to Obsidian as notes.
`neoth groundtruth ask "<q>"`	Query the immutable-facts register; contradictions get flagged, not overwritten.
`neoth identity merge`	The same person on Telegram, WhatsApp, and email becomes one identity.
`neoth recall-score`	LongMemEval-style memory benchmark with inter-rater kappa — prove recall quality.
`neoth memory-eval`	Reproducible recall benchmark in a temp DB; never touches real memory.
`neoth cost "<prompt>"`	Token count and dollar estimate before the call is made.
`neoth lease grant codex code:write --ttl 30m`	Time-limited capability grant that auto-expires; WAL-logged.
`neoth recipe share`	Prompt template as a `neoth://recipe/…` deeplink anyone can run with their own parameters.
`neoth adr extract`	Architecture Decision Records extracted from your sessions as structured files.
`neoth okf export`	Your memory as an interlinked Obsidian knowledge graph.
`neoth kanban watch --follow`	Live terminal feed of task progress, streamed from WAL frames.
`neoth companion pair-phone`	QR-code phone pairing over Noise-XX P2P; no relay server.

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:

Only in NEOTH	Prove it
Collapse prediction on its own runtime (Babel-Index)	`neoth babel status`
HMAC-chained audit log you can verify yourself	`neoth verify`
Evidence-linked profile memory behind explicit consent	`neoth profile pending`
WASM capability sandbox that refuses + audits over-level calls at runtime	`neoth plugin ledger`
Fail-closed trust boundaries as the default, not a setting	`neoth privacy audit --last 30d`

Capability	NEOTH	OpenHuman	OpenClaw	Hermes Agent
GUI-first normal-user onboarding	Yes	Yes	Partial	Yes (desktop app)
CLI/operator path	Yes	Partial	Yes	Yes
Local-first memory as default product shape	Yes	Partial	Yes	Yes
Fail-closed profile extraction	Yes	Partial	Partial	Partial
Evidence-linked profile facts	Yes	Partial	Partial	Partial
WAL/audit trail for sensitive actions	Yes	Partial	Partial	Partial
Five-tier memory model + vault ingest	Yes	No	No	Partial
Three role-bound brain paths	Yes	No	Partial	Partial
Collapse prediction on its own runtime (Babel-Index)	Yes	No	No	No
Coding canvas + Kanban	Yes	Partial	Canvas-focused	Desktop cockpit + Kanban
Obsidian/vault workflow	Yes	Yes	File-based	Context-file based
Paperless/email/calendar as memory inputs	Yes	Integrations	Skills/tools	Tools/skills
n8n localhost automation	Yes	No	Partial	Cron/tools
WASM plugin capability sandbox	Yes	No	Skills	Skills/tools
Private mesh with Tailscale/Hysteria/Keet path	Partial	No	Gateway/nodes	Gateway/platforms
Built for DAUs and pros at the same time	Goal	DAU-heavy	Power-user-heavy	Operator-heavy

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
is Partial — node discovery, Tailscale/mDNS pairing, the consent gate, and transport
config ship today, but live cross-device memory sync (tracked as SL-01) is still in
progress. 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 the headless cross-compiled server targets (musl /
aarch64-linux) omit it, the same native-only treatment as the OS clipboard. 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.

Read the detailed migration pages:

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

Need	Doc
Start from zero	docs/quickstart.md
Install paths	docs/install.md
Privacy proof	docs/privacy.md
Verify the claims yourself	docs/evaluation.md
CLI reference	docs/cli-reference.md
Channels	docs/channels.md
Local models	docs/local-models.md
Providers	docs/providers.md
Plugins	docs/plugins.md
Babel-Index / collapse prediction	docs/babel-index.md
Architecture	docs/architecture.md
Release notes	docs/release-notes-v1.0.md
Security policy	SECURITY.md
Contributing	CONTRIBUTING.md

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.