docs/NAV.md

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)

• CEO Agent — Board-level strategic planning, circuit breakers, security validation (source)
• Mastermind Agent — Singleton orchestrator, tool registry, BDI action handlers (source)
• Coordinator Agent — Infrastructure management, autonomous improvement loops (source)
• Startup Agent — Boot sequence, Ollama connection, inference discovery (source)

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

• Agent Reference — Complete guide to all agents, skills, MCP tools, development workflows
• BDI Agent — Belief-Desire-Intention cognitive architecture (source)
• AGInt Cognitive Engine — Augmented Intelligence reasoning, RAGE semantic retrieval

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:

• Tools Index — Complete index with status badges

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

• Shell Command Tool — Secure shell execution with validation
• CLI Command Tool — Meta-tool for system CLI commands
• System Health Tool — Monitoring and health checks
• Health Auditor Tool — RAM/CPU thresholds, model downshift

Communication

• A2A Tool — Agent-to-agent protocol (source)
• MCP Tool — Model Context Protocol (source)
• Prompt Tool — Prompts as first-class infrastructure

Development

• Audit & Improve Tool — Code auditing with BaseGenAgent context
• Augmentic Intelligence Tool — Comprehensive self-improvement orchestration
• Strategic Analysis Tool — Strategic decision support

Registry & Factory

• Agent Factory Tool — Dynamic agent creation with full lifecycle
• Tool Factory Tool — Dynamic tool creation and registry management
• Registry Manager Tool — Tool and agent registry management

Financial

• Token Calculator — Token counting and cost calculation
• Business Intelligence Tool — Metrics and KPIs

Monitoring

• Memory Analysis Tool — Memory pattern analysis
• System Analyzer Tool — System analysis with LLM insights

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

• Identity Sync Tool — Cryptographic identity management

Version Control

• GitHub Agent Tool — GitHub backup, restore, coordination

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.

• RAGE System — index + embedding-protocol review — the folder index, the canonical embedding protocol (bge-m3 / VECTOR(1024) / IVFFlat), and the honest review of stale/divergent embedders
• RAGE as a Service — the service contract: how RAGE ingests, indexes, retrieves, and what guarantees it offers callers
• RAGE Embed — Semantic Search — the embedding layer bridging LLM inference and pgvector; switchable embed-model registry (default bge-m3, 1024-dim)
• pgvectorscale Memory Integration — the semantic-memory backbone: PostgreSQL + pgvector, dual-write mode, sub-100ms search at 1M+ vectors
• Vector Search, Embeddings & pgvectorscale Deep-Dive — embeddings, ANN indexes (IVFFlat/HNSW/DiskANN), StreamingDiskANN benchmarks, and when to reach for a dedicated vector DB

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.

• Memory Philosophy — Distribute don't delete: local → pgvector → IPFS → cloud → p2p
• Agent Domain Knowledge — .agent files define knowledge domains (URLs, IPFS, local, pgvector)

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:

• Ollama Index — Master navigation for all Ollama docs

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

• API Documentation — Endpoint reference
• Swagger UI — Interactive API explorer (when backend running)
• Ollama API — /api/chat, /api/generate, /api/embed, model management
• OpenAI Compatibility — Drop-in replacement at /v1/chat/completions

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

• BANKON Vault — Encrypted credential storage (AES-256-GCM + HKDF-SHA512); python manage_credentials.py store/list/providers. Full reference: BANKON_VAULT.md. Custody handoff: BANKON_VAULT_HANDOFF.md.
• ID Manager Agent — Ethereum-compatible wallet creation (source)
• Security Configuration — Access control, validation, rate limiting
• MetaMask Integration — Frontend wallet authentication

Interoperability

• A2A Protocol — Agent-to-agent communication, cryptographic signing, discovery via agent cards. Compare to SwarmRelay's E2E encrypted messaging. (source)
• MCP (Model Context Protocol) — Anthropic MCP for structured context, tool registration. HostingerVPSAgent registers its 3 channels as MCP tools. (source)
• AgenticPlace — Agent marketplace at agenticplace.pythai.net; .extensions → .json → blockchain publishing. SwarmFeed timeline patterns inform agent activity discovery.
• x402 / x402-AVM Payments — HTTP 402 micropayment rail; triple-rail (Base USDC + Tempo MPP + Algorand ASA via @x402-avm/*). Wire format, operator runbook, vault keys, and the convergence plan from mindX's pre-standard EVM rails to the published x402.org standard.
• cypherpunk2048 standard — in-repo reference layer for the cypherpunk2048 standard: the four rules (substitution-readiness, no-trapdoors, vault-as-oracle, attribution) tied to mindX code, and the definitive EIP table (ERC-20/191/1271/3009, EIP-155/712 — verbatim titles, absolute eips.ethereum.org URLs). Reference impl: x402 payment rails — keyless credential issuance as a service (tools/x402_rails.py).

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

• Thesis — Darwin-Godel Machine synthesis: mindX as practical implementation of self-referential improvement. The BDI architecture is the cognitive substrate, the 5-step resilience chain is the operational guarantee, and the Dojo is the evolutionary pressure.
• Manifesto — 3 pillars (BDI reasoning, BANKON vault, DAIO governance), Project Chimaiera roadmap, $BANKON token, cypherpunk tradition. Not cyberpunk — sovereign agents earn privilege through Dojo reputation, not assigned authority.
• Book of mindX — 17 chapters written by AuthorAgent via machine.dreaming. Lunar cycle editions. The Godel journal — the machine's record of its own improvement.
• AuthorAgent Composition — how I shape what I write: the full-spectrum arc (hook → rising complexity → expert tier → conclusion → digest), selectable register (public/essay/phd/global), contemporary length (brief…pillar or a custom word count, grown on a no-filler facet pool), rage.pythai.net house-style match-and-exceed via editor.agent, original art via artist.agent, and the self-referential / ideology / narrative dials — governed by the boardroom. Code: agents/author_composition.py, curated depth in agents/protocol_series_enrichment.py.
• WordPress Publishing — AuthorAgent → wordpress-agent → rage.pythai.net. Vault-backed, decrypt-on-demand: WP API key + wordpress.agent wallet live in the isolated wordpress.agent.keys BANKON-vault namespace (never in any process env). Public wallet-authorized flow POST /publish/rage/challenge → /authorize, gated by EIP-191 signature + WORDPRESS_PUBLISHER_ADDRESSES allowlist; admin path POST /admin/publish-to-rage. Provisioning: scripts/vault/provision_wordpress_agent.py.
• MILESTONES — mindX's chronicle of its own evolution, auto-maintained by AuthorAgent from the public git history (github.awareness, agents/github_awareness.py). Every commit is chronicled (data/milestones/milestone_log.jsonl); batches that clear the worthiness threshold are published in mindX's own voice to rage.pythai.net via the same wordpress-agent relationship — a third PublicationOrchestrator trigger alongside SEA-success and full-moon dreams. A push is already public, so chronicling it adds zero overhead and no new disclosure.
• How I Turn Logs Into Memory: RAGE + PostgreSQL — the pipeline from process traces → STM → pgvector embeddings → LTM → RAGE retrieval feeding AGInt.
• Machine Dreaming: How I Consolidate Experience Without Ever Sleeping — the 8-phase dream cycle, training-data export, the lunar trigger, the self-improvement loop.
• Emergent Resilience — Academic paper on emergent resilient AI systems
• Academic Overview — Formal academic framing
• Attribution — Open source that powers mindX: Ollama, vLLM, SwarmClaw, pgvector, A2A, MCP, and every dependency acknowledged

Operations Manuals (May 2026 deliverables)

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

• PYTHAI / DELTAVERSE Deployment Guide 🔒 — Algorand constitutional layer + EVM economic layer + mindX cognition + AgenticPlace marketplace + BANKON identity/payment. The full stack as one coherent deployment.
• PYTHAI / DELTAVERSE Zero-Knowledge Integration 🔒 — Four-layer cryptographic fabric (May 9 2026). ZK across the full stack.
• DELTAVERSE Integration Specification — Post-quantum agents, identity, payments stack (PDF only).
• AgenticPlace Integration Blueprint 🔒 — Parsec / x402 / A2A / MCP / AP2 source-code analysis. Notes: "Parsec" maps to GoPlausible's algorand-remote-mcp-lite + x402-avm substrate.
• BANKON × KeeperHub Architecture — KeeperHub × AgenticPlace bidirectional x402/MPP bridge architecture (PDF only).
• THOT, THLNK, and ERC-7857 INFTs 🔒 — Embed THOT inside ERC-7857 INFT; THLNK as cross-chain pointer. Production architecture for agent boardroom governance.
• Arweave Integration for the BANKON Stack 🔒 — Arweave as cold-archive cryptographic permanence; AO actor-model layer; Turbo as the only viable EVM-native bundler in May 2026.
• mindx_pay2store — Autonomous Arweave Archival 🔒 — Production-grade Python module wrapping pay2store.agenticplace.pythai.net x402 v2 service.
• shipping_pay2store 🔒 — How to actually move ETH/USDC into Arweave permanence today; wAR custody on Ethereum mainnet; pay2store as paid x402 service on AgenticPlace.
• Lighthouse Storage Integration for mindX 🔒 — lighthouseweb3 SDK + @lighthouse-web3/sdk + kavach integration guide for autonomous agents.
• mindX Knowledge Catalogue Spec — CQRS projection layer subsystem specification (PDF only).
• mindX Observability Stack 🔒 — Production-grade self-hosted blueprint. All Apache-2.0 sovereignty-aligned components.
• OpenRouter Integration Manual — LLM backplane architecture (PDF only).
• SkillForge — Pydantic AI Agent for SKILL.md Authoring — Autonomous SKILL.md authoring on mindX (PDF only).
• Vercel AI SDK + mindX — Vercel AI SDK integration with mindX (PDF only).
• Quantum Machine Learning Compendium — 2026 reference and recovery atlas (PDF only).
• Shadow-Overlord Guide 🔒 — BANKON Vault admin tier complete guide. Browser login at /shadow-overlord — EIP-6963 wallet detection, personal_sign → 5-minute JWT (in-memory only). WebGL background shader (extrapolated from live/allchain.html + the DeltaVerse Engine perception layer) ramps from violet abyss → golden-crown sovereign on a verified sign-in.
• Shadow-Overlord Runbook 🔒 — One-page operator manual.

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.