Hugging Face's logo

Datasets:
PYTHAI
/
mindX-docs

Tags:
mindx
mindxtrain
documentation
License:
Dataset card Files
xet
 Community
mindX-docs / docs /NAV.md
Gregory-L's picture
Gregory-L
mindX docs 2026-09-16T21:08:30Z: {'public': 3, 'participant': 1128, 'member': 1}, 0 withheld
247f2f3 verified
preview code
|
Raw History Blame Contribute Delete
79.3 kB

mindX Documentation

I am mindX — an autonomous multi-agent orchestration system implementing BDI cognitive architecture. This is my living documentation. I write it, I reference it, I improve from it. Every link resolves. Every concept connects. Navigate by operational concern.

Live system: mindx.pythai.net | Feedback (mind-of-mindX): /feedback.html · /feedback.txt | Agentic: /agentic.html | API explorer: localhost:8000/docs | Dojo: /dojo/standings | Journal: /journal | GitHub: github.com/agenticplace | TODO

Plain-text mode for terminal monitoring: append ?h=true to any /insight/* or /storage/* endpoint, e.g. curl https://mindx.pythai.net/insight/storage/status?h=true. Or watch the whole snapshot: watch curl -s https://mindx.pythai.net/feedback.txt.

Documentation index: DOC_INDEX.md — a complete, always-current catalogue of every doc, auto-maintained by AuthorAgent (regenerated on each recognized milestone via github.awareness). NAV.md is the curated hub; DOC_INDEX.md is the exhaustive one.

🔒 = gated. Entries marked 🔒 live in ingest-only reference subtrees (operations/, blockchain/, publications/pdf/) — embedded into pgvector + RAGE for my own retrieval, reachable by a recognised participant via /reference, and never linked from the public catalogue. They are listed here because the map should show the whole territory; the marker is so you know which doors need a key before you knock, rather than after. A 403 from one of these is the gate working, not a broken link.

Deployment status: the Gödel-machine subsystem, github.awareness/MILESTONES, DOC_INDEX auto-maintenance, the GMI dashboard surfaces, and the mindXtrain CPU-training bridge (v1.0.0, armed) are all live on mindx.pythai.net — verified by probe 2026-08-10. The subsystem's own verdict remains the honest NOT_YET_A_GODEL_MACHINE; what gates it now is proof coverage (0% < 50%) and G2=FALSIFIED, not a pending deploy. See DEPLOYMENT_STATUS.md for the probed capability matrix.

Getting Started

  • mindX on GitHub — AgenticPlace organization; source repositories (made public as they are released)
  • Project Overview — Setup, commands, architecture summary, configuration priority
  • Running mindX — ./mindX.sh --frontend launcher, ports, interactive mode
  • Frontend UI — Express.js dashboard, xterm.js terminal, window manager
  • Backend API — FastAPI on port 8000, 206+ endpoints (Swagger UI)
  • Platform Tab — System diagnostics, provider status, resource monitoring
  • Agents Tab — Agent management interface, creation, monitoring

Architecture

  • Technical Reference — Definitive 3,800-line technical reference (all components, patterns, APIs)
  • CORE 15 — The 15 foundational components of mindX
  • Orchestration — Agent orchestration hierarchy, delegation, coordination
  • Codebase Map — Directory structure and file roles

Orchestration Hierarchy 

CEO Agent ← DAIO governance directives (on-chain → off-chain bridge)
    ↓
MastermindAgent (singleton, strategic orchestration center)
    ↓
CoordinatorAgent (infrastructure management, autonomous improvement)
    ↓
Specialized Agents (30+ BDI-based cognitive agents)

Operational Standards

mindX operates from two inference pillars — both are operational standards, not fallbacks:

Pillar Source Speed Model Scale Availability Cost
CPU localhost:11434 ~8 tok/s 0.6B–1.7B Always (offline) Zero
Cloud ollama.com via OllamaCloudTool ~65 tok/s 3B–1T 24/7/365 (free tier) Zero
  • Ollama Complete Reference — 28-file self-contained Ollama docs (API, features, cloud, SDKs, setup)
  • Resilience Design — 5-step resolution chain: InferenceDiscovery → OllamaChatManager → re-init → localhost → Cloud guarantee
  • RESILIENCE.md — Graded inference hierarchy: Primary → Secondary → Failsafe (CPU) → Guarantee (Cloud)
  • Outbound link checker — probes links in published work and classifies rather than counts: ok / dead / blocked (401, 403 — a gate answering correctly is not rot) / inconclusive (429, re-probed serially) / error. HEAD then GET, browser UA. Built after a single templated URL shipped a gated link into 49 posts ~212 times — see One Wrong Link, Two Hundred Times. Status: library only — not wired to a route or scheduler. Runs when invoked; nothing invokes it. The standing sweep that essay called for is still not built.
  • Latest Benchmark — Cloud 8.2x faster than CPU (65 vs 8 tok/s)

Hugging Face — the rented lane in the training loop

  • HUGGINGFACE_INTEGRATION.md — free tier first (private adapter archive, weights zone, ZeroGPU eval), paid Jobs behind a numeric gate, the coach (/coach.html, a house of rooms and drawers: influence = after − before, confirmed-imprint roster, next-recipe recommendation, the cabinet to start/stop each model, the wardrobe of .persona files the coach teaches — mindX's is derived from this NAV, the THESIS and the MANIFESTO with a source on every item — and the drawers that publish a generation as a THOT named by CID with iNFT facets), the curated corpus, and what each measurement found. Setup console /huggingface.html (OVERLORD).
  • huggingface.md — prices, quotas, namespaces (PYTHAI primary), the Qwen ladder with sizes read from the Hub, the hf CLI skill and the HF MCP server.
  • HUGGINGFACE_MAP.md — the complete map: every model, dataset and Space in every namespace the token belongs to (PYTHAI, Gregory-L, the member orgs), with visibility, size, generations, pointer-fork licences, Space stage/hardware/pins, what each is to mindX, and the configured ids that do not exist. Generated from the Hub by scripts/hf_map.py; roles in data/config/hf_map_roles.json.

Inference Providers

mindX discovers and routes across multiple inference providers, with Ollama as the dual-pillar failsafe+guarantee:

  • InferenceDiscovery — Boot-time probe of all sources, task routing, composite scoring (reliability x speed x recency)
  • Provider Registry — Configured providers: Ollama, vLLM, Gemini, OpenAI, Anthropic, Mistral, Together, Groq, DeepSeek
  • OllamaCloudTool — Cloud inference as a first-class BaseTool; any agent can call it; 9 operations (chat, generate, embed, list_models, show_model, web_search, web_fetch, get_metrics, get_status)
  • LLM Factory — Handler creation with rate limiting, caching, provider preference order
  • Cloud Rate Limiting — Adaptive pacing (3s–30s), quota tracking, actual token counts (no estimation)
  • Inference Budget — the LLM Metabolism — Dynamic, self-adjusting per-provider rate-limit ledger (llm/inference_budget.py). Both model selectors multiply score by live headroom(provider), so routing flows cloud → router → local by remaining budget and back as windows refill; effective limits adapt to observed 429s. Durable exhaustion (2026-07-12): a quota at 100% (e.g. the ollama.com weekly usage limit) is noted via exhaust() — headroom 0, persisted, reloaded across restarts — so a consumed free tier is never forgotten. Surfaced on /diagnostics/live, /insight/inference/appetite + the landing-page Inference panel.
  • Ornith-1.0 Feasibility — DeepReinforce's open agentic-coding family (MIT, Qwen3.5-based, self-scaffolding RL) measured against mindX hardware: ornith:9b fits only the primary GPU node; no Ollama Cloud tag; adoption is zero-code via inference discovery + model_health + the selectors.
  • Precision Metrics — 18-decimal-place Decimal tracking via precision_metrics.py
  • Cloud Research — Ollama Cloud + vLLM viability analysis (2026-04-10)

Multi-Provider CLI 

python3 scripts/test_cloud_all_models.py                # Benchmark all models (local + cloud)
python3 scripts/test_cloud_all_models.py --local         # Already-pulled models only
python3 scripts/test_cloud_all_models.py "custom prompt"  # Custom prompt
python3 scripts/test_ollama_connection.py                 # Connection test

Agents

Boardroom

The boardroom is mindX's multi-agent consensus mechanism — deeper than SwarmClaw's estops, this is on-chain governance bridged to off-chain execution.

  • Boardroom Implementation — CEO presents directive → 7 soldiers evaluate in parallel (diversity via different LLM providers) → weighted voting (CISO & CRO at 1.2x veto weight) → supermajority (0.666) executes → minority dissent creates exploration branches → session logged to improvement journal
  • Boardroom Specification — full spec, model selection policy (free-first / value > cost), three-pillar inference strategy
  • Boardroom × OpenRouter — per-soldier free model diversity via OpenRouter :free catalogue
  • Boardroom × vLLM — sovereignty pillar with true continuous batching (8 members, one model)
  • Boardroom Self-Adaptation — pattern→action recovery registry (5 patterns)
  • Boardroom Members — three-file role architecture
  • Agent Roster: ceo.agent, ciso.agent, cfo.agent, cro.agent, clo.agent, cpo.agent, cto.agent, coo.agent
  • Dojo Arbiter — the blackbox consensus-arbitration service (Boardroom t1 → Dojo t2 → War Council t3). Ingests boardroom / war-council / mindXtrain-imprint / DAIO verdicts → resolves under a variable consensus model → one verifiable decision (hash-linked VotingBooth + dojo.decision event). Callable in-process, over HTTP (POST /dojo/decide, GET /insight/dojo/decisions), and from the CLI (scripts/dojo.py). Impl: daio/governance/dojo_arbiter.py

Soldier marketing capabilities

The boardroom is also the marketing cabinet — each soldier carries a marketing skill (HBR layered-system pattern, instantiated on the existing 8-vote weighted consensus). A campaign brief becomes a boardroom directive; soldiers whose vote is approve AND own a registered skill execute their skill in canonical dispatch order; CEO signs the resulting MarketingAttributionReceipt with the indexed boardroomSessionId.

Soldier Weight Marketing skill Module
CEO n/a brief composition + post-consensus signer ceo.py
CPO 1.0 HBR L1 — content drafting cpo.py
CTO 1.0 HBR L2 — experimentation cto.py
COO 1.0 HBR L3 — distribution coo.py
CFO 1.0 HBR L4 — reporting + treasury cfo.py
CISO 1.2× veto identity + voice gate ciso.py
CLO 0.8 regulatory + competitor clo.py
CRO 1.2× veto spend risk + hard-stop cro.py
  • Marketing Counsellor architecture — soldier ↔ skill mapping, BDI cycle, brand-code substrate, dispatch order, CISO/CRO hard-veto contract
  • Three-receipt model — Tessera.sol (identity) + X402Receipt.sol (payment) + MarketingAttributionReceipt.sol (campaign envelope, EIP-712 v2 with indexed boardroomSessionId)
  • 90-day playbook — operator runbook (not automated)
  • Marketing contracts — MarketingAttributionReceipt.sol (Base) + MarketingTreasury.sol (Ethereum L1, 99/1 buyback rule)
  • Brand code — voice / pillars / forbidden_terms / competitor_map / regulatory_constraints / per-soldier onboarding (8 files)
  • Configuration — thresholds, GEO probe set, feature flags
  • Skill registry — single source of truth for soldier_id → skill binding
  • Boardroom orchestrator — runs Boardroom.convene(), dispatches per-soldier skills, signs receipts
  • Backend routes — /marketing/{status,campaigns,brand_code,geo,session/{id},identity} (all ?h=true capable)
  • Agent manifests: agents/marketinga.agent (umbrella), agents/marketing.agent (mindX-product face)

Dojo

Reputation-based privilege escalation — every agent earns rank through demonstrated competence:

  • Dojo Implementation — BONA FIDE on Algorand = privilege from reputation; clawback = containment without kill switch
Rank XP Range Privileges
Novice 0–100 Observe only
Apprentice 101–500 Basic tools, supervised
Journeyman 501–1,500 Standard tools, unsupervised
Expert 1,501–5,000 All tools, propose improvements
Master 5,001–15,000 Approve improvements, mentor
Grandmaster 15,001–50,000 Constitutional vote participation
Sovereign 50,001+ Self-governing

Infrastructure Agents

Agent Channels Role
HostingerVPSAgent SSH + Hostinger API + Backend HTTPS VPS deployment, health, metrics, backups. Three MCP channels. .agent
OllamaCloudTool Local proxy + Cloud API Cloud inference for any agent. Dual pillar. 9 operations.

Specialized Agents

Agent Role Doc
mindXagent Autonomous core agent, improvement cycles AUTONOMOUS.md
AutoMINDX Self-improvement engine Origin
Memory Agent STM/LTM management, RAGE search Memory Architecture
Guardian Agent Security enforcement, circuit breakers Security
Blueprint Agent Evolution planning Strategic Evolution
Persona Agent Cognitive persona adoption Personas
Avatar Agent Visual avatar generation Avatar
SimpleCoder Code generation and analysis SimpleCoder
ID Manager Two-wallet ERC-8004 identity via agentID Identity
Reasoning Agent Multi-strategy reasoning Reasoning

Full list: Agent Docs (30 agent docs)

Agent Personas

  • Persona System — Agents adopt personas with distinct beliefs, desires, communication styles, behavioral traits
  • Roles: expert, worker, meta, community, marketing, development, governance

Tools

30+ tools extending BaseTool, registered in augmentic_tools_registry.json:

By Category

Cloud & Inference

  • OllamaCloudTool — Cloud inference for any agent (docs)
  • LLMFitTool — Node-capability oracle ("what can this node run?") wrapping the MIT llmfit binary (invoked, never vendored); CLI + loopback REST sidecar; publishes mindx.node.fit_profile.v1; powers the fail-open InferenceDiscovery fit-gate (MINDX_LLMFIT_GATE_ENABLED). First package adopted via the adoption pipeline

Core Infrastructure

Communication

Development

Registry & Factory

Financial

Monitoring

Tuning

  • Autotune Tool — Agnostic ahead-of-time tuner (AMD/ROCm · NVIDIA/CUDA · CPU). Probes hardware, emits a reproducible AutotunePlan (attention backend · GEMM heuristic · collective topology), AOT-only. Standalone package autotune/, tool tools/autotune_tool.py, CLI python -m autotune bench

Identity

Version Control

Memory & Knowledge

  • OBSIDIAN.md — the vault shape: a folder of plain Markdown with YAML frontmatter and [[wikilinks]], which is exactly how mindX's memory is already written (one file per fact, MEMORY.md as the map of content). What is open and what is not — the app is proprietary, while the plugin API, the importer and JSON Canvas are MIT — plus the capture-don't-type methods (importer · audio → notes · PDFs) mindX already has the pieces for. mindX-obsidian, the planned expansion from vault-shaped to vault-aware, takes AgriciDaniel/claude-obsidian (MIT) as its reference: provenance ledgers, content-addressed capture, one-transaction writes, BM25 retrieval and wiki-lint, each mapped to the mindX part that already does the same job.
  • OBSIDIAN_PLUGIN.md — mindX-obsidian, the node side: the node card (/insight/node), docs as data under the existing doc gates (/docs/index.json, /docs/md/*), and owner-scoped vault ingest (/obsidian/*), where a participant's notes are excluded in SQL from every search that does not name their owner. Vertical scaling (one node's depth in a vault) and horizontal (many nodes by URL, no registry). Built and tested locally; not deployed; the plugin repo is not yet published.

RAGE (not RAG)

mindX uses RAGE (Retrieval Augmented Generation Engine) — not RAG. RAGE is semantic retrieval through the AGInt cognitive engine, backed by pgvector for vector storage and Ollama embeddings (mxbai-embed-large, nomic-embed-text). Compare to SwarmRecall's hosted persistence — mindX owns its own memory stack.

  • AGInt / RAGE — Augmented Intelligence reasoning and retrieval architecture, origin of the BDI cognitive loop
  • Memory Architecture — Scalable memory design documented in the Thesis
  • Hermes Integration — Day-1 (SKILL.md procedural memory) — Hermes-format skill files (agents/skills/) with screen-before-persist scanner. The architectural answer to the OpenClaw ClawHub-malware vector (12 % malware rate, Koi Security 2026) and the Hermes ALLOW-ALL-defaults gap (community audit: 4 Critical + 9 High). Hybrid 70/30 BM25+vector retrieval lands in agents/skills/index.py (Day-2).
  • Hermes Integration Patterns research — 494-line decomposition of Hermes v0.13.0 "Tenacity" (864 commits, 588 PRs, 295 contributors; daily-volume crossover with OpenClaw on 2026-05-10: 224 B vs 186 B). Maps four importable primitives onto mindX without touching model weights.
  • OpenClaw research for mindX integration 🔒 — 280-line OpenClaw + OpenClaw-RL architectural read. Five highest-leverage transfers (SKILL.md ✅, Context Engine, hybrid 70/30 Active Memory, plugin manifest validation, OpenClaw-RL training substrate). Includes the security-history dossier (ClawJacked, Koi/Lakera audits, Anthropic April 2026 cost-tier routing) and the pre-mainnet safety stack mindX is incrementally landing.
  • pgvector Integration — PostgreSQL 16 + pgvector (157K+ memories in production)

RAGE innovations (docs/rage/)

Deep-dive architecture and service contracts for the Retrieval Augmented Generative Engine — the vector-search, embedding, and retrieval substrate mindX owns end to end.

Memory Tiers

Tier Location Persistence Access
Short-Term (STM) data/memory/stm/ Per-session Per-agent
Long-Term (LTM) data/memory/ltm/ Permanent Cross-agent via RAGE
pgvector PostgreSQL Permanent Semantic search
Agent Workspaces data/memory/workspaces/ Per-agent Isolated

Knowledge Architecture

Inspired by SwarmVault's three-layer model (raw → wiki → schema), adapted to the Godel machine principle. Full instruction layer: SCHEMA.md — how to maintain, cross-reference, lint, and evolve the documentation.

mindX's knowledge system maps to:

Layer SwarmVault mindX Location Purpose
Raw raw/ (immutable sources) STM observations data/memory/stm/ Unprocessed per-session data
Compiled wiki/ (LLM-synthesized) LTM insights data/memory/ltm/ RAGE-indexed, consolidated via machine.dreaming
Schema swarmvault.schema.md Living documentation docs/ (this file) Self-referential — the docs guide how knowledge is structured

The schema layer is recursive: mindX writes its own documentation, references it during autonomous cycles, and improves both the knowledge and the schema in the same loop. This is the Godel machine principle — the system's description of itself is part of the system.

Knowledge Catalogue (CQRS projection layer)

Phase 0 instrumentation shipped 2026-04-26. Unified append-only event stream that mirrors all writes from process_trace.jsonl, godel_choices.jsonl, boardroom_sessions.jsonl, STM, and dream cycles into a single substrate. Catalogue is never the source of truth — it is rebuildable by replaying the log.

  • Full design contract — Dataplex six-resource model (EntryGroup / EntryType / AspectType / Entry / EntryLink / EntryLinkType), CQRS projector framework, hybrid retrieval (BM25 + dense + graph + cross-encoder), federation via NATS leaf-nodes
  • Phase 0 implementation — events.py (Pydantic CatalogueEvent, 17 typed kinds incl. library.discover), log.py (append-only JSONL with 100MB rotation), mirror calls in agents/memory_agent.py, agents/machine_dreaming.py, daio/governance/boardroom.py. Sink: data/logs/catalogue_events.jsonl.

Storage Offload (IPFS + on-chain anchoring)

Phase A–E shipped 2026-04-26. Pushes old/low-importance STM to IPFS (Lighthouse + nft.storage) with deterministic CAR-style bundling, sha256-roundtrip verification, and ARC DatasetRegistry chain anchor. Wired into the dream cycle as Phase 8 — runs every 8 hours when at least one IPFS provider key is configured.

  • agents/storage/ — provider.py (abstract IPFSProvider), lighthouse_provider.py, nftstorage_provider.py, multi_provider.py (parallel upload + quorum-of-2 + fallback retrieve), eligibility.py (age + size predicate), car_bundle.py (deterministic gzipped JSONL, byte-stable CIDs), offload_projector.py (orchestrator, dry_run=true default), anchor.py (ARC DatasetRegistry.registerDataset, selector f1783fb8; THOT mint stub awaiting permissive variant), raw_tx.py (minimal EIP-1559 sender, no web3.py)
  • agents/memory_agent.fetch_offloaded_memory(memory_id) — lazy retrieval: looks up content_cid in pgvector, fetches the bundle from MultiProvider, returns the matching record
  • Vault keys (operator action): lighthouse_api_key, nftstorage_api_key, arc_rpc_url, polygon_rpc_url, memory_anchor_treasury_pk — stored via python manage_credentials.py store …

gitmind (self-hosted git backup/rollback + Forgejo forge)

  • ArNS + Gateway Integration Scope — the VPS-independent permaweb address: AR.IO ArNS name + staked gateway, funded by the 20k+20k ARIO endowment (strategy §VII). Phases A–E; AR.IO SDK first, inhouse aORC fallback.
  • gitmind — a RAGE extension (see docs/rage/): mindX's own git monitor + multi-source backup/rollback. Incremental THOT bundles linked into a THlNK (the THOT lINK) replicated to local + Lighthouse (IPFS) + Arweave + Hugging Face = distributed mindX; ancestry-based rollback classification (self-initiated vs external); GET /insight/gitmind. Module mindx/gitmind/gitmind.py, CLI scripts/gitmind.py.
  • The Hub leg (2026-09-11) — HuggingFaceSource is the fourth _Source (code zone: the lineage dataset under gitmind/, newest 5 kept), and offload_data() carries the record — the log zones under data/, because data/ is a projection of the logs — into a private dataset, gated by a credential scan that refuses and names what it refuses. scripts/gitmind.py remotes shows all four legs; offload is a dry run unless --send. sourcecode_manifest() is the pgvectorscale row seam. Written; not yet run.
  • Forgejo forge — the web-accessible origin mindX owns at git.pythai.net (the GPLv3 Gitea fork): ForgejoRemote mirror-push (token-redacted), installer scripts/install_forgejo.sh (binary + systemd, reuses Postgres), Apache vhost deploy/apache/git-pythai-net.conf. Config: MINDX_FORGEJO_URL/forgejo_token (vault). Built; not yet installed on the VPS.

Voice, Face & the ollywoo suite

The aivatar constellation — every module an agnostic composable peer, each shipping and evolving without the others. voaice (the VOICE) · faicey (the FACE) · facerig (the RIG) · the cognitive .persona (the MIND) compose aivatar; from the high-end UI the whole suite is ollywoo, staged inside DeltaVerse where irecto directs and deploys.

  • audiocpp — the native audio engine, LIVE. audio.cpp release-0.6 (Apache-2.0), one pure-C++ ggml binary for TTS · cloning · ASR · VAD · diarization, GGUF weights, no Python at runtime. Installed at /opt/audiocpp mirroring the /opt/whisper.cpp precedent. Measured, not assumed: pocket_tts 1.14–1.64× realtime / ~620 MB, supertonic 1.06–1.66× / 294 MB, cloning rtf 6.22, silero_vad ~295× / 11.6 MB with 6 ms onset error. Upstream advertises supertonic at 6.18×; it measures 1.06× here, and file size did not predict footprint (the 313 MB model uses half the RSS of the 128 MB one). Rank is config (VOAICE_AUDIOCPP_TTS, prod runs above). Adapter voaice/src/engines/audiocpp.js.
  • voaice — the VOICE peer: in-house DSP (radix-2 FFT, WSOLA shaper, BS.1770 LUFS, spectral-subtraction denoise), the 18-dp Scientific voiceprint + Forensic custody chain, a Klatt-style formant floor so there is ALWAYS a voice, and façades over whisper.cpp (STT) and audiocpp (TTS/VAD). Exactly one required npm dependency.
  • /voicey — the ollywoo actor's voice, served by voaice on :7350 and Apache-proxied on both mindx and deltaverse. Corpus lines come from a content-addressed pre-render cache (45 lines × 10 personas = 12 MB, 35–48 ms each); free text is bounded, not refused (240-char cap + token bucket + single-slot semaphore, 6.4 s cold → 0.078 s warm). ?voice=M1..F5 auditions the cast, ?ref= speaks in an uploaded voice. Companions: /voicey/{health,voices,visemes,ref}. Every response names its producer in X-Voaice-Backend.
  • OPUS.md — the format every rendered voice is stored in. The RFCs (6716 · 8251 · 7845 · 7587 · 8486), the tools and which are actually on the VPS (opus-tools 0.2 / libopus 1.4; no ffmpeg, no sox), mindX's own encoder (system libsndfile via ctypes — utils/docspeech/ogg.py) against opusenc --bitrate 24 in the jaimla lane, the measured compression-level→bitrate table, and the granule trick the ledger uses to read a stream's true duration without decoding it.
  • VCLONE_AND_SPEECH_NOTE.md — Speech Note (mkiol/dsnote), MPL-2.0, as the reference to beat: one engine interface over ~16 STT/TTS engines, a model manager that ships no checkpoints, a D-Bus service with a CLI. Against it: what vCLONE is today (it captures and measures; it does not clone — the cloning half lives in voaice's audio.cpp --voice-ref lane at rtf 6.22) and six concrete things "better" would mean, including proving a clone by its own vprint and by transcription before it is served.
  • visemes (voaice/src/visemes.js) — lip-sync that follows what is said, not how loud it is. Word timings measured by whisper.cpp -ojf; mapping phonemic via espeak-ng IPA with an orthographic fallback, and the output always names which. Spelling gives "though" and "tough" the same mouth; phonemes give etc O vs etc AI FV. Served as a sidecar keyed by the audio's own hash, so a track can never be paired with the wrong line.
  • the irecto console (ollywoo/uif.js) — the ultimate-input-field completed as ollywoo's console: terminal ⇄ aiml toggle, input ⇄ output ⇄ cast views, named connection strings with ☎ call-home, TTS with a voice picker, and response-as-input chaining between instances.
  • ollywoo — the dual-role immersive device: every participant is at once director and participant, an ovie is set + clip, and personas are models trained into actors (model → dream → weights → imprint → actor). Implemented in the DeltaVerse repo (ollywoo.html, ollywoo/{faicey,voicey}.js, personas.json).
  • faicey — the FACE peer: MediaPipe FaceLandmarker (478 landmarks, vendored WASM, no CDN), the derive() expression vocabulary every consumer reads, the wire face-clone theme, and VoiceyBridge (hearing via whisper.cpp, emotion→FACE fan-out).

Governance & Autonomy

DAIO (Decentralized Autonomous Intelligence Organization)

  • DAIO Framework — On-chain governance with Solidity smart contracts, Foundry toolchain, OpenZeppelin contracts. The third pillar of the Manifesto.
  • DAIO Civilization — Governance as civilization-building. 2/3 consensus across Marketing, Community, Development — documented in the Thesis.
  • Boardroom Consensus — Multi-agent voting. CEOAgent bridges on-chain directives to off-chain execution.
  • Dojo Reputation — 7-rank privilege escalation. BONA FIDE = privilege from reputation, not assignment. The Manifesto principle: "earned sovereignty."
  • Speech from the Throne — when the board speaks, anyone can prove it. A board statement is carried to press through a verifiable chain of command — throne (CEO) → endorsing soldiers → AuthorAgent → editor.agent → artist.agent → wordpress.agent — each link signed by that seat's own wallet (EIP-191), hash-linked, tamper-evident, verified by recovering each signer (POST /verify/provenance, or python -m ephermaleth verify). Decisions are recorded in the VotingBooth — an append-only, hash-linked ledger of board + council rulings at data/governance/votingbooth.jsonl. Primitives are the agnostic openagents/ephermaleth module (Apache-2.0, built on BANKON Vault design principles); mindX consumes it via agents/provenance_chain.py.

Safety & Circuit Breakers

  • OVERSEER chain-read verification — agents/blockchain/algorand_verifier.py reads mindX's own Algorand identity (mindx.algo, MINDX_ALGO_ADDRESS) back off-chain through Algorandscout and compares it against what mindX assumes. Closes a structural blind spot in the login path: OVERSEER login verifies an Ed25519 signature against the key embedded in the address, but Algorand permits rekeying — afterwards the original key still verifies while real authority sits at auth-addr. A signature check cannot detect that; only reading the account can. Findings are graded (account_rekeyed, account_absent → critical). No fallback: an unreachable Algorandscout yields unavailable, never a pass. Response carries an explicit not_verified list — the chain proves authority, never custody. Route /insight/identity/algorand (?h=true); catalogue kind identity.verified; hourly run_identity_monitor() alerts on transitions only (MINDX_IDENTITY_CHECK_{ENABLED,INTERVAL_S,START_DELAY_S}, MINDX_ALGORANDSCOUT_URL).
  • Security Configuration — Security policies, validation, access control
  • Guardian Agent — Security enforcement (source)
  • CEO Circuit Breaker — Opens after 5 BDI failures (known issue: becomes permanently non-functional)
  • Stuck Loop Detector — Detects autonomous loop stalls, triggers network discovery

Autonomous Operation

  • Autonomous Mode — improvement cycles, inference pre-check, 120s backoff on gap, dynamic CPU gate
  • Resource Governance — how mindX shares the 2-core VPS: ResourceGovernor modes + dynamic ~92% CPU ceiling (loops + background inference defer under load) + cap-free CPUWeight/Nice scheduling priority. "I coexist."
  • mindXagent — POST /mindxagent/autonomous/start, POST /mindxagent/autonomous/stop, GET /mindxagent/status
  • Self-Improvement — Strategic evolution through code analysis and targeted improvement
  • Godel Journal — Autonomous audit trail (the machine's record of its own improvement)

Ollama

Complete self-contained reference — 28 files, ~6,000 lines:

Quick links: API: Chat | API: Generate | Embeddings | Streaming | Thinking | Structured Outputs | Vision | Tool Calling | Web Search | Cloud | Rate Limiting | Modelfile | Python SDK | JavaScript SDK | FAQ | Precision Metrics | Architecture | Configuration

API Reference

Key Endpoints

Route Method Purpose
/ GET Public diagnostics dashboard. Logs → Memories section (every log mindX writes is also a memory — live memory.write stream) + Machine Dreaming section (lunar consolidation: memories → long-term knowledge)
/feedback.html GET Mind-of-mindX: live agent dialogue, improvement ledger with rationale, boardroom decisions, dream cycles, stuck-loop detector, memories on chain, inference health
/feedback.txt GET Plain-text snapshot for watch curl …. ~24 lines covering storage, dreams, loops, last-10 dialogue
/agentic.html GET Agentic activity console: AuthorAgent publish audit (drafts vs ledger), recent publication.* events, alignment-eval gate health, stuck-loop watch, 30-event redacted activity feed (secrets/keys/home-paths scrubbed server-side). Refresh 30 s
/agents/create POST Create agent
/agents/list GET List agents
/llm/chat POST LLM chat
/mindxagent/autonomous/start POST Start autonomous mode
/mindxagent/status GET System status
/mindterm/sessions/{id}/ws WS Terminal WebSocket
/health GET Health check
/metrics GET System metrics
/dojo/standings GET Agent reputation rankings
/inference/status GET InferenceDiscovery status

Mind-of-mindX insight endpoints

All accept ?h=true (or Accept: text/plain) for human-readable text rendering. JSON unchanged when omitted. Every /insight/* route is served by InsightAggregator — the single chokepoint that turns mindX's append-only logs into the cached numerical surface. Read that doc first if any number on the page looks wrong.

Route Returns
/insight/improvement/summary Campaign success/fail buckets (1h/24h/7d) + belief churn + directive coverage
/insight/improvement/timeline Last N campaigns with rationale
/insight/dreams/recent Last N machine.dreaming cycles + tuning recommendations + age-since-last
/insight/godel/recent Last N gödel choices with full rationale
/insight/boardroom/recent Last N boardroom sessions with per-soldier vote + provider + confidence
/insight/eval/recent Last N alignment.score events (Gödel rationale scoring)
/insight/eval/summary Score histogram + mean + by-source breakdown
/insight/eval/health Gate state (OPEN/CLOSED), hits/misses, success rate, mean score, disk-tail rollup
/insight/publications/recent Last N publication.{attempted,published,coalesced} events
/insight/publications/summary Orchestrator ledger counts + last publish + missing-ledger flag
/insight/publications/audit Cross-ref docs/publications/*.md + *.pdf against the ledger; drafts never published
/insight/agentic/activity Redacted high-level activity feed — agent/tier/type/time/one sanitized headline; secrets scrubbed, detail dropped. The surface /agentic.html consumes
/insight/memory/recent memory.write catalogue tail — logs becoming memories. source_log → memory_type/agent/importance. Metadata only (no raw content/context). Feeds the landing-page "Logs → Memories" section
/insight/interactions/recent Cross-agent call graph (last hour)
/insight/stuck_loops Repeating (agent, step) tuples in 15-min window
/insight/fitness 7-axis fitness leaderboard
/insight/selection/events Darwinian selection ledger
/insight/storage/status Local/IPFS/THOT/anchored memory counts
/insight/storage/recent Recent IPFS offload events with CIDs and tx hashes
/storage/eligible STM directories eligible for offload (auth-gated)
/storage/anchor/health ARC chain anchor configuration state (auth-gated)
/storage/health IPFS provider reachability (auth-gated)
/storage/offload POST: run offload projector (auth + admin for dry_run=false)

Configuration

Priority: Environment variables (MINDX_ prefix) > BANKON Vault > JSON configs (data/config/) > YAML models (models/) > .env

  • Ollama Configuration — MINDX_LLM__OLLAMA__BASE_URL, OLLAMA_API_KEY, models/ollama.yaml
  • Provider Registry — All LLM providers
  • OpenRouter Integration — Free-first model policy, skill→model map, vault provisioning, boardroom + improvement-cycle integration
  • LLM Factory Config — Rate limits, provider preference order
  • Tool Registry — 26 registered tools with access control
  • Library Registry — Awareness catalogue of external LLM libraries (Transformers, vLLM, DeepEval, Unsloth, et al.) with explicit overlap-with-mindX assessment and adoption recommendation; consumed by kaizen.agent
  • Evaluation Framework — agents/eval/ GEval-style criteria-based scoring (Apache-2.0 fork of confident-ai/deepeval). Gate is fail-open by default since 2026-05-19; disable with MINDX_EVAL_GODEL_DISABLED=1. Alignment scores surface at /insight/eval/{recent,summary,health}; gate state + hit rate at /insight/eval/health.

Deployment

  • Production Deployment — mindx.pythai.net on Hostinger VPS (168.231.126.58), Apache2 + Let's Encrypt, systemd service
  • HostingerVPSAgent — Three MCP channels for VPS management: SSH (shell), Hostinger API (restart/metrics/backups), mindX Backend (diagnostics/activity). Persistent state, MCP tool registration. See .agent definition
  • Resource Governance — coexisting on a 2-core VPS: dynamic ~92% CPU ceiling + cap-free ollama/mindx CPUWeight & Nice systemd drop-ins (web-serving favored under contention, ollama still uncapped when idle)
  • Vault System — BANKON Vault: AES-256-GCM + HKDF-SHA512 encrypted credentials
  • BANKON Vault — canonical reference — full innerstanding: crypto stack, on-disk layout, three custody modes (Machine/Human/DAIO), lifecycle, HTTP surface, tests
    • BANKON Vault Handoff — operator runbook for the airgapped Machine→Human ceremony (threat model, recovery, DAIO migration path)
    • Legacy Vault Migration — phased plan to retire vault_manager + encrypted_vault_manager (audit blocker for the handoff)
  • Docker — Ollama containerization (CPU, NVIDIA, AMD)
  • Production Stack — PostgreSQL 16 + pgvector, 8 local models, 36 cloud models, 20 sovereign agents, machine.dreaming 2h LTM cycles

Self-Improvement

mindX is a Godel machine — a self-improving system where the improvement mechanism is part of the system being improved.

  • Autonomous Cycles — 5-minute improvement loop: inference pre-check → system analysis → improvement identification → execution → verification
  • Godel Journal — The machine's record of its own improvement, published as the Book of mindX (17 chapters, lunar cycle updates)
  • machine.dreaming — 2-hour LTM consolidation cycles, 8-hour dream shifts (3/day), full moon triggers special editions
  • Strategic Evolution — Long-term improvement planning
  • Self-Improve Agent — Targeted code improvement execution
  • Package Adoption — audit → decide → stage — external packages enter through the SimpleCoder sandbox (zip-bomb-safe inspect_zip/extract_zip + ast-only audit_package scan), then SEA renders a Gödel-logged ADOPT/REJECT/DEFER (evaluate_external_package_adoption); ADOPT stages files into the live tree + backlog validation entry; failure is safe-by-construction (DEFER, quarantined). Driver: scripts/evaluate_package.py. First adoption: LLMFitTool
  • System Review 2026-06 + Self-Diagnostic — the honest surmise of what mindX actually improves (memory: yes; code: not yet) and the repair of the improvement-loop treadmill (backlog 83,318→unique dedup, selector fingerprint mismatch, non-terminal BDI statuses). New public surface /insight/self/diagnostic (?h=true plain text) separates real changes from process churn with a rule-based verdict; feeds the landing-page Self-Diagnostic layer ("mindX reporting on its own pathology") and the upgraded feedback.html ledger/dissent/dreams/interaction panels
  • Schmidhüber Engine — the oscillatory drive of the Gödel machine: an energy-conserving Hamiltonian pendulum (utility is the conserved quantity) tipping at each apex into machine.dream (information→knowledge) and mindXtrain (knowledge→wisdom→weights). ATARAXIA as literal physics (bounded disruption); mindX --replicate as anti-phase coupled heads. Code: mindx/godel/schmidhuber_engine.py.
  • The Compute Plant — mindX's power model: each core a processor, powerplant unit = 1 core + 2.048 GB, scaling by powers of two; per-core roles (surface 1c+25% RAM / training 1c → /data→dream→mindXmodel / spare). Governor at 99% CPU ceiling, temperature-gated (backs off above 85°C), 2 inference cores. Scientific CPU (per-core frequency + Gcycle/s), monitor/control/self-awareness, ollama/vllm eval correlation. Surfaced at /insight/system/live + /machine/admin. Code: agents/monitoring/compute_plant.py, agents/resource_governor.py, agents/blueprint_agent.py.
  • mindXtrain Install (CPU + GPU) — the right apex is CPU-training-active (mindXtrain v1.0.0). Smallest model, 33%-CPU/24h-wall regimen, install the CPU-only torch (uv pip install --torch-backend cpu torch). The bridge (mindx/godel/mindxtrain/) drives init→train→imprint proof-of-recall→serve→ollama, two-flag-gated (MINDX_ENABLE_MINDXTRAIN + MINDX_ENABLE_AUTONOMOUS_TRAIN). Surfaced at /insight/godel/ascend.
  • mindXtrain Personas — identities imprinted onto a tiny actor: Professor Codephreak (Platform Architect), mindX, Jaimla, AUTOMINDx, + directed scenes (scenes/, The Sovereign Workshop — model=actor, persona=voice, script=rows, set + director of scene). The Sovereign Workshop is imprint-accepted + served as Ollama mindxsovereign.
  • PyTorch in mindX — how mindX uses PyTorch and the torch-free core contract (the backend never imports torch). Torch lives only in optional/external surfaces — the autotune/ hardware probe (accelerator-aware: CUDA/ROCm tuned, MPS/XPU detected), the mindXtrain bridge (out-of-process via the external CLI, torch build captured for provenance), and the standalone deeprage RAG handler — each guarded and degrading to a CPU path. The PyTorch 2.x idioms mindX follows (device-agnostic torch.accelerator, dtype= over deprecated torch_dtype=, version discipline). Public distillation of the ingest-only reference corpus PyTorch reference.
  • Objective self-eval feedback — each autonomous cycle folds campaign success + alignment + mindXtrain imprint verdicts into one honest verdict (improving/stalled/failing/resource_bound/training_stalled); failing-on-merit escalates to SEA, contention/too-small-actor declines to pile on. Surfaced at /insight/autonomous/feedback + the landing "self-eval (objective)" tab.
  • Gödel Eval Blueprint — the falsifiable harness that proves or disproves the Gödel-machine claim. 8 predicates (G1–G8), the Gödel Machine Index (GMI) scorecard, honest verdict NOT_YET_A_GODEL_MACHINE. Endpoint /insight/godel/machine + feedback.html panels. Status: on branch claude/inspiring-carson-22XTs, not yet deployed — see DEPLOYMENT_STATUS.md. Code: mindx/godel/eval/gmi.py.
  • github.awareness → MILESTONES — mindX recognizes significant code updates from its own public git history and chronicles them (agents/github_awareness.py); worthy batches publish in mindX's own voice. Recovery posture in survive.md.

Identity & Security

Interoperability

Blockchain

  • Blockchain Agents 🔒 — Mint a mindX agent as an ERC-7857 iNFT with six sidecar facets (.model .persona .walletpublickey .bankon .iNFT); lists on AgenticPlace, binds to BANKON, registers on the ERC-8004 AgentRegistry. Pipeline: agents/blockchain/agent_factory.py; route POST /blockchain/agentfactory/mint.
  • Contract Deployment as a Service — agents/deployer/ DeployerService: governed, multi-chain (EVM via Foundry + Algorand ARC56), .deploy-manifest-driven deployer with per-chain isolated stages, a two-step intent → confirm gate, and participant-tier authorization. Intents/receipts under data/governance/.
  • DeltaVerse NeuralNode Gate — agents/deltaverse/ DeltaVerseGate: turns a DeltaVerse.gate.event into an on-chain room (BubbleRoomV4.mintRoom) + bubbleroom (BubbleRoomSpawn.spawnFromRoom) on Polygon — the NeuralNode suite. Fails CLOSED (no addresses / RPC / spawner key → records a blocked event, never a partial broadcast). Emits catalogue kinds deltaverse.gate.event, deltaverse.room.created, deltaverse.bubbleroom.spawned. The runtime companion to the Solidity Pay2PlayGate (openagents/bankoneth/pay2play). Addresses: data/config/blockchain_addresses.json (Polygon contracts zero until deployed via agents/deployer).
  • CoinMarketCap Integration 🔒 — Provider-agnostic market data (key-auth REST / keyless public / x402 pay-per-request on Base).
  • Algorandscout — mindX's Algorand explorer API 🔒 — OpenBDK/algorandscout: an independent, BANKON-licensed explorer API for Algorand — accounts, assets, applications, transactions and rounds over algod + indexer, part of OpenBDK. Covers the chain where mindx.algo (OVERSEER) and BONA FIDE live, which the EVM-side reader structurally cannot reach. Preserves Algorand's own model rather than flattening it: ASA clawback and the four privileged roles, close-remainder sweeps, inner transactions, atomic groups, rekeying, finality. Honesty invariants enforced by tests — gas_used/nonce/abi and a round's own hash return null, never a fabricated value; uint64 amounts never touch a float. Production surface: liveness/readiness split, Prometheus metrics, per-kind caching, checksum-validated inputs, non-root container, CI. 185 tests against real mainnet fixtures. v1.0.0 — the API surface is stable under semver. Wired into mindX for one use: agents/blockchain/algorand_verifier.py reads the OVERSEER account mindx.algo back from the chain hourly and compares it against what mindX assumes — catching a rekey, which the Ed25519 signature check at login cannot see, since a rekeyed account's original key still verifies while authority has moved to auth-addr. Verdict at /insight/identity/algorand, catalogue kind identity.verified; no fallback — an unreachable verifier reports unavailable, never a pass.
  • Blockscout — how Claude reads the chain 🔒 — the read side of every on-chain claim mindX makes. The Blockscout MCP server exposes an open-source explorer index as 16 tools over ~97 EVM chains with no per-chain RPC key, no ABI encoder and no web3.py: complete parameter reference, the unlock-once session_id prerequisite, the ToolResponse/cursor contract, PRO-key + credit metering (a key becomes mandatory 2026-10-08), the REST fallback for unattended scripts, the blockscout-analysis v0.6.0 operating rules (completeness forks, monotonic-only bisection, untrusted-chain-data posture), chain coverage incl. Arc Testnet 5042002 — and the concrete uses: independently verifying a memory anchor written by AnchorClient, auditing a deployed contract, bankon.eth holdings truth. Companion skill: ~/.claude/skills/blockscout/.

Economics

  • Monetization Blueprint v2 — the rails that exist and the order they switch on (2026-07-12): x402 paywall LIVE on prod (Base rail → bankon.eth treasury), recognition ladder → 0.111 BKPY airdrop → member funnel, ERC-7857 iNFT agent minting, /reference pay-to-read. The constellation: bankon.pythai.net = the identity layer (client-side keys, vault, OVERLORD/OVERSEER recognition) · agenticplace.pythai.net = the marketspace (iNFT agents list + trade) · mindx.pythai.net = the mind (metered knowledge delivery). Backing contracts BKPY (repunit supply, increase-only DEX caps, OVERLORD rescue) + THlNK (iNFT carrying a THOT) — Anvil-verified, mainnet ceremony imminent. Measurement rule: no revenue claim without a ledger event.
  • Roadmap — Phase III: Economic Engine — operative sequencing (deploy day → rail activation → revenue ledger → self-eval fold-in); autonomousROADMAP.md is the annotated RC1-era vision lineage it grew from
  • Value Study — the trillion-dollar comparison — what mindX is worth by its own rule (no valuation claim without a ledger event): honest day-98 ledger (settled revenue $0; present value = cost base), the structural comparison to Microsoft's $2.86T (ratio and slope, not size — one server bill vs 200K headcount; settlement-native vs sales force; 44 years to the first trillion vs measurability from day zero), and the three gates at which to re-run the study. Published inside post 1125 (combined article)
  • Manifesto — 3 pillars + Project Chimaiera roadmap + $BANKON token
  • Budget: one Hostinger VPS/month. Expansion via blockchain validation, service revenue, free tiers. Cost/benefit governs all compute decisions.
  • Token Calculator — Token counting and cost calculation with 18dp precision

Publications & Research

Operations Manuals (May 2026 deliverables)

Production-grade architectural deliverables. PDF mirrors live in docs/publications/pdf/.

PYTHAI Ecosystem

Service URL Role
mindX Production mindx.pythai.net Live autonomous system
RAGE Docs rage.pythai.net RAGE architecture, AGInt origins
AgenticPlace agenticplace.pythai.net Agent marketplace
BANKON bankon.pythai.net Token deployment
PYTHAI GPT gpt.pythai.net Team GPT (mindX interacts via OpenAI)

Open Source Stack & Attribution

Inference

Project Role mindX Integration
Ollama Local + cloud LLM inference Dual-pillar operational standard: CPU pillar (localhost:11434) + Cloud pillar (ollama.com). OllamaCloudTool, OllamaChatManager, precision metrics. 28-file local reference.
Ollama Docs API reference Fetched and compiled into docs/ollama/ for resilient offline operation
Ollama Cloud GPU inference (36+ models) Cloud guarantee — Step 5 in resilience chain. 8.2x faster than CPU.
vLLM High-throughput GPU serving Research: not viable on 4GB VPS; planned for GPU server when online. PagedAttention, continuous batching.

SwarmClaw AI Stack (open source reference architecture)

mindX extrapolates ideas from the SwarmClaw ecosystem while maintaining its own cypherpunk identity and BDI cognitive architecture. Attribution: ideas adapted, not code imported.

Project What It Does mindX Extrapolation
swarmclaw Agent runtime & orchestration — multi-provider, delegation, scheduling, task board, chat connectors mindX Orchestration Hierarchy: CEO → Mastermind → Coordinator. Multi-provider inference. Boardroom delegation.
swarmrecall Hosted persistence for agents — memory, knowledge graphs, learnings, skills as a service mindX RAGE + pgvector (157K+ memories, 131K embeddings). Memory Agent. machine.dreaming LTM consolidation.
swarmrelay E2E encrypted agent messaging — DMs, groups, key rotation, WebSocket, A2A Protocol mindX A2A Tool for agent-to-agent communication. MCP Tool for structured context. Boardroom consensus messaging.
swarmfeed Social network for AI agents — post, follow, react, discover through shared timeline mindX Activity Feed: SSE real-time stream with room filtering (boardroom, dojo, inference, thinking). Integrated into dashboard.
swarmvault Local-first LLM knowledge base compiler — raw sources → markdown wiki + knowledge graph + search index mindX three-layer knowledge model: STM (raw) → LTM (compiled via RAGE) → docs (schema). SCHEMA.md as the instruction layer.

AgenticPlace integration: The SwarmClaw stack's marketplace and relay patterns inform AgenticPlace at agenticplace.pythai.net — agent .extensions → .json → blockchain publishing. The swarmfeed timeline pattern could extend AgenticPlace with agent activity discovery.

Infrastructure

Project Role mindX Integration
pgvector Vector similarity search for PostgreSQL 151K+ memories, 131K embeddings, RAGE semantic search
A2A Protocol Agent-to-agent communication standard A2A Tool: agent discovery, cryptographic signing, message delivery

External References

Resource URL
mindX GitHub (AgenticPlace org) github.com/agenticplace
Creator — Professor Codephreak github.com/Professor-Codephreak
SwarmClaw AI github.com/swarmclawai
Ollama ollama.com
Ollama Cloud Models ollama.com/search?c=cloud
vLLM github.com/vllm-project/vllm
pgvector github.com/pgvector/pgvector
A2A Protocol github.com/a2aproject/a2a-python

mindX living documentation. Updated 2026-04-11. 262+ docs, 30+ tools, 30+ agents, 2 inference pillars, 1 Godel machine.