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](https://mindx.pythai.net) | **Feedback (mind-of-mindX)**: [/feedback.html](https://mindx.pythai.net/feedback.html) · [/feedback.txt](https://mindx.pythai.net/feedback.txt) | **Agentic**: [/agentic.html](https://mindx.pythai.net/agentic.html) | **API explorer**: [localhost:8000/docs](http://localhost:8000/docs) | **Dojo**: [/dojo/standings](https://mindx.pythai.net/dojo/standings) | **Journal**: [/journal](https://mindx.pythai.net/journal) | **GitHub**: [github.com/agenticplace](https://github.com/agenticplace) | **[TODO](TODO.md)**

**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](DOC_INDEX.md) — a complete, always-current catalogue of every doc, **auto-maintained by [AuthorAgent](AUTHOR_AGENT.md)** (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`](https://mindx.pythai.net/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](DEPLOYMENT_STATUS.md) for the probed capability matrix.

---

## Getting Started

- [mindX on GitHub](https://github.com/agenticplace) — AgenticPlace organization; source repositories (made public as they are released)
- [Project Overview](../CLAUDE.md) — Setup, commands, architecture summary, configuration priority
- [Running mindX](mindXsh.md) — `./mindX.sh --frontend` launcher, ports, interactive mode
- [Frontend UI](mindxfrontend.md) — Express.js dashboard, xterm.js terminal, window manager
- [Backend API](api_documentation.md) — FastAPI on port 8000, 206+ endpoints ([Swagger UI](http://localhost:8000/docs))
- [Platform Tab](platform-tab.md) — System diagnostics, provider status, resource monitoring
- [Agents Tab](agents-tab.md) — Agent management interface, creation, monitoring

## Architecture

- [Technical Reference](TECHNICAL.md) — Definitive 3,800-line technical reference (all components, patterns, APIs)
- [CORE 15](CORE.md) — The 15 foundational components of mindX
- [Orchestration](ORCHESTRATION.md) — Agent orchestration hierarchy, delegation, coordination
- [Codebase Map](codebase_map.md) — 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](agents/ceo_agent.md) — Board-level strategic planning, circuit breakers, security validation ([source](../agents/orchestration/ceo_agent.py))
- [Mastermind Agent](agents/mastermind_agent.md) — Singleton orchestrator, tool registry, BDI action handlers ([source](../agents/orchestration/mastermind_agent.py))
- [Coordinator Agent](agents/coordinator_agent.md) — Infrastructure management, autonomous improvement loops ([source](../agents/orchestration/coordinator_agent.py))
- [Startup Agent](agents/startup_agent.md) — Boot sequence, Ollama connection, inference discovery ([source](../agents/orchestration/startup_agent.py))

## 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`](../tools/cloud/ollama_cloud_tool.py) | ~65 tok/s | 3B–1T | 24/7/365 (free tier) | Zero |

- [Ollama Complete Reference](ollama/INDEX.md) — 28-file self-contained Ollama docs (API, features, cloud, SDKs, setup)
- [Resilience Design](ollama/INDEX.md#resilience-design) — 5-step resolution chain: InferenceDiscovery → OllamaChatManager → re-init → localhost → **Cloud guarantee**
- [RESILIENCE.md](../llm/RESILIENCE.md) — Graded inference hierarchy: Primary → Secondary → Failsafe (CPU) → Guarantee (Cloud)
- [Outbound link checker](../agents/link_checker.py) — 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*](https://rage.pythai.net/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](ollama/INDEX.md#latest-benchmark-2026-04-11) — Cloud 8.2x faster than CPU (65 vs 8 tok/s)

## Hugging Face — the rented lane in the training loop

- [**HUGGINGFACE_INTEGRATION.md**](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](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**](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](../llm/inference_discovery.py) — Boot-time probe of all sources, task routing, composite scoring (reliability x speed x recency)
- [Provider Registry](../data/config/provider_registry.json) — Configured providers: Ollama, vLLM, Gemini, OpenAI, Anthropic, Mistral, Together, Groq, DeepSeek
- [OllamaCloudTool](../tools/cloud/ollama_cloud_tool.py) — Cloud inference as a first-class [BaseTool](../agents/core/bdi_agent.py); any agent can call it; 9 operations (chat, generate, embed, list_models, show_model, web_search, web_fetch, get_metrics, get_status)
- [LLM Factory](../llm/llm_factory.py) — Handler creation with rate limiting, caching, provider preference order
- [Cloud Rate Limiting](ollama/cloud/rate_limiting.md) — Adaptive pacing (3s–30s), quota tracking, [actual token counts](ollama/mindx/precision_metrics.md) (no estimation)
- [**Inference Budget — the LLM Metabolism**](INFERENCE_BUDGET.md) — Dynamic, self-adjusting per-provider rate-limit ledger ([`llm/inference_budget.py`](../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](ORNITH_FEASIBILITY.md) — 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](ollama/mindx/precision_metrics.md) — 18-decimal-place `Decimal` tracking via [`precision_metrics.py`](../llm/precision_metrics.py)
- [Cloud Research](OLLAMA_VLLM_CLOUD_RESEARCH.md) — Ollama Cloud + vLLM viability analysis (2026-04-10)

### Multi-Provider CLI

```bash
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](AGENTS.md) — Complete guide to all agents, skills, MCP tools, development workflows
- [BDI Agent](agents/bdi_agent.md) — Belief-Desire-Intention cognitive architecture ([source](../agents/core/bdi_agent.py))
- [AGInt Cognitive Engine](AGINT.md) — 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](../daio/governance/boardroom.py) — 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](BOARDROOM.md) — full spec, model selection policy (free-first / value > cost), three-pillar inference strategy
- [Boardroom × OpenRouter](agents/boardroom_openrouter.md) — per-soldier free model diversity via OpenRouter `:free` catalogue
- [Boardroom × vLLM](agents/boardroom_vllm.md) — sovereignty pillar with true continuous batching (8 members, one model)
- [Boardroom Self-Adaptation](agents/boardroom_self_adaptation.md) — pattern→action recovery registry (5 patterns)
- [Boardroom Members](agents/boardroom_members.md) — three-file role architecture
- **Agent Roster**: [`ceo.agent`](../agents/boardroom/ceo.agent), [`ciso.agent`](../agents/boardroom/ciso.agent), [`cfo.agent`](../agents/boardroom/cfo.agent), [`cro.agent`](../agents/boardroom/cro.agent), [`clo.agent`](../agents/boardroom/clo.agent), [`cpo.agent`](../agents/boardroom/cpo.agent), [`cto.agent`](../agents/boardroom/cto.agent), [`coo.agent`](../agents/boardroom/coo.agent)
- [**Dojo Arbiter**](DOJO_ARBITER.md) — 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`](../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`](../agents/marketing/skills/ceo.py) |
| CPO | 1.0 | HBR L1 — content drafting | [`cpo.py`](../agents/marketing/skills/cpo.py) |
| CTO | 1.0 | HBR L2 — experimentation | [`cto.py`](../agents/marketing/skills/cto.py) |
| COO | 1.0 | HBR L3 — distribution | [`coo.py`](../agents/marketing/skills/coo.py) |
| CFO | 1.0 | HBR L4 — reporting + treasury | [`cfo.py`](../agents/marketing/skills/cfo.py) |
| CISO | 1.2× **veto** | identity + voice gate | [`ciso.py`](../agents/marketing/skills/ciso.py) |
| CLO | 0.8 | regulatory + competitor | [`clo.py`](../agents/marketing/skills/clo.py) |
| CRO | 1.2× **veto** | spend risk + hard-stop | [`cro.py`](../agents/marketing/skills/cro.py) |

- [Marketing Counsellor architecture](MARKETING_AGENT.md) — soldier ↔ skill mapping, BDI cycle, brand-code substrate, dispatch order, CISO/CRO hard-veto contract
- [Three-receipt model](MARKETING_RECEIPTS.md) — `Tessera.sol` (identity) + `X402Receipt.sol` (payment) + `MarketingAttributionReceipt.sol` (campaign envelope, EIP-712 v2 with indexed `boardroomSessionId`)
- [90-day playbook](MARKETING_PLAYBOOK.md) — operator runbook (not automated)
- [Marketing contracts](../daio/contracts/marketing/README.md) — `MarketingAttributionReceipt.sol` (Base) + `MarketingTreasury.sol` (Ethereum L1, 99/1 buyback rule)
- [Brand code](../data/brand_code/) — voice / pillars / forbidden_terms / competitor_map / regulatory_constraints / per-soldier onboarding (8 files)
- [Configuration](../data/config/marketinga.toml) — thresholds, GEO probe set, feature flags
- [Skill registry](../agents/marketing/skills/registry.py) — single source of truth for `soldier_id → skill` binding
- [Boardroom orchestrator](../agents/marketing/boardroom_orchestrator.py) — runs `Boardroom.convene()`, dispatches per-soldier skills, signs receipts
- [Backend routes](../mindx_backend_service/marketing_routes.py) — `/marketing/{status,campaigns,brand_code,geo,session/{id},identity}` (all `?h=true` capable)
- Agent manifests: [`agents/marketinga.agent`](../agents/marketinga.agent) (umbrella), [`agents/marketing.agent`](../agents/marketing.agent) (mindX-product face)

### Dojo

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

- [Dojo Implementation](../daio/governance/dojo.py) — 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](../agents/hostinger_vps_agent.py) | SSH + [Hostinger API](https://developers.hostinger.com) + [Backend HTTPS](https://mindx.pythai.net) | VPS deployment, health, metrics, backups. Three MCP channels. [.agent](../agents/hostinger.vps.agent) |
| [OllamaCloudTool](../tools/cloud/ollama_cloud_tool.py) | Local proxy + [Cloud API](https://ollama.com) | Cloud inference for any agent. [Dual pillar](ollama/INDEX.md#operational-standards). 9 operations. |

### Specialized Agents

| Agent | Role | Doc |
|-------|------|-----|
| [mindXagent](../agents/core/mindXagent.py) | Autonomous core agent, improvement cycles | [AUTONOMOUS.md](AUTONOMOUS.md) |
| [AutoMINDX](agents/automindx_agent.md) | Self-improvement engine | [Origin](AUTOMINDX_ORIGIN.md) |
| [Memory Agent](agents/memory_agent.md) | STM/LTM management, RAGE search | [Memory Architecture](mindx_memory_architecture_scalable.md) |
| [Guardian Agent](agents/guardian_agent.md) | Security enforcement, circuit breakers | [Security](security_configuration.md) |
| [Blueprint Agent](agents/blueprint_agent.md) | Evolution planning | [Strategic Evolution](agents/strategic_evolution_agent.md) |
| [Persona Agent](agents/persona_agent.md) | Cognitive persona adoption | [Personas](automindx_and_personas.md) |
| [Avatar Agent](agents/avatar_agent.md) | Visual avatar generation | [Avatar](agents/avatar_agent.md) |
| [SimpleCoder](SimpleCoder.md) | Code generation and analysis | [SimpleCoder](SimpleCoder.md) |
| [ID Manager](agents/id_manager_agent.md) | Two-wallet ERC-8004 identity via agentID | [Identity](agents/id_manager_agent.md) |
| [Reasoning Agent](agents/reasoning_agent.md) | Multi-strategy reasoning | [Reasoning](reasoning.md) |

Full list: [Agent Docs](agents/) (30 agent docs)

### Agent Personas

- [Persona System](automindx_and_personas.md) — Agents adopt personas with distinct beliefs, desires, communication styles, behavioral traits
- Roles: expert, worker, meta, community, marketing, development, governance

## Tools

30+ tools extending [`BaseTool`](../agents/core/bdi_agent.py), registered in [`augmentic_tools_registry.json`](../data/config/augmentic_tools_registry.json):

- [Tools Index](TOOLS_INDEX.md) — Complete index with status badges

### By Category

**Cloud & Inference**
- [OllamaCloudTool](../tools/cloud/ollama_cloud_tool.py) — Cloud inference for any agent ([docs](ollama/INDEX.md))
- [LLMFitTool](../tools/inference/llmfit_tool.py) — 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](PACKAGE_ADOPTION.md)

**Core Infrastructure**
- [Shell Command Tool](shell_command_tool.md) — Secure shell execution with validation
- [CLI Command Tool](cli_command_tool.md) — Meta-tool for system CLI commands
- [System Health Tool](system_health_tool.md) — Monitoring and health checks
- [Health Auditor Tool](system_health_tool.md) — RAM/CPU thresholds, model downshift

**Communication**
- [A2A Tool](a2a_tool.md) — Agent-to-agent protocol ([source](../tools/communication/a2a_tool.py))
- [MCP Tool](mcp_tool.md) — Model Context Protocol ([source](../tools/communication/mcp_tool.py))
- [Prompt Tool](prompt_tool.md) — Prompts as first-class infrastructure

**Development**
- [Audit & Improve Tool](audit_and_improve_tool.md) — Code auditing with BaseGenAgent context
- [Augmentic Intelligence Tool](augmentic_intelligence_tool.md) — Comprehensive self-improvement orchestration
- [Strategic Analysis Tool](strategic_analysis_tool.md) — Strategic decision support

**Registry & Factory**
- [Agent Factory Tool](agent_factory_tool.md) — Dynamic agent creation with full lifecycle
- [Tool Factory Tool](tool_factory_tool.md) — Dynamic tool creation and registry management
- [Registry Manager Tool](registry_manager_tool.md) — Tool and agent registry management

**Financial**
- [Token Calculator](token_calculator_tool_robust.md) — Token counting and cost calculation
- [Business Intelligence Tool](business_intelligence_tool.md) — Metrics and KPIs

**Monitoring**
- [Memory Analysis Tool](memory_analysis_tool.md) — Memory pattern analysis
- [System Analyzer Tool](system_analyzer_tool.md) — System analysis with LLM insights

**Tuning**
- [Autotune Tool](../autotune/README.md) — 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](identity_sync_tool.md) — Cryptographic identity management

**Version Control**
- [GitHub Agent Tool](GITHUB_AGENT.md) — GitHub backup, restore, coordination

## Memory & Knowledge

- [**OBSIDIAN.md**](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](https://github.com/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**](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](AGINT.md), backed by [pgvector](https://github.com/pgvector/pgvector) for vector storage and [Ollama embeddings](ollama/features/embeddings.md) ([`mxbai-embed-large`](https://ollama.com/library/mxbai-embed-large), [`nomic-embed-text`](https://ollama.com/library/nomic-embed-text)). Compare to [SwarmRecall](https://github.com/swarmclawai/swarmrecall)'s hosted persistence — mindX owns its own memory stack.

- [AGInt / RAGE](AGINT.md) — Augmented Intelligence reasoning and retrieval architecture, origin of the [BDI cognitive loop](agents/bdi_agent.md)
- [Memory Architecture](mindx_memory_architecture_scalable.md) — Scalable memory design documented in the [Thesis](THESIS.md)
- [Hermes Integration — Day-1 (SKILL.md procedural memory)](HERMES_INTEGRATION.md) — 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](operations/Hermes%20Agent%20Integration%20Patterns%20for%20mindX_%20Self-Improving%20Architecture%20Analysismd) — 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](operations/openclaw_mindx_research.md) 🔒 — 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](rage/pgvectorscale_memory_integration.md) — [PostgreSQL 16](https://www.postgresql.org/) + [pgvector](https://github.com/pgvector/pgvector) (157K+ memories in [production](DEPLOYMENT_MINDX_PYTHAI_NET.md))

#### 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](rage/rage_system.md) — the folder index, the canonical embedding protocol (`bge-m3` / `VECTOR(1024)` / IVFFlat), and the honest review of stale/divergent embedders
- [RAGE as a Service](rage/rage_as_a_service.md) — the service contract: how RAGE ingests, indexes, retrieves, and what guarantees it offers callers
- [RAGE Embed — Semantic Search](rage/EMBEDDING_SYSTEM.md) — the embedding layer bridging LLM inference and pgvector; switchable embed-model registry (default `bge-m3`, 1024-dim)
- [pgvectorscale Memory Integration](rage/pgvectorscale_memory_integration.md) — the semantic-memory backbone: PostgreSQL + pgvector, dual-write mode, sub-100ms search at 1M+ vectors
- [Vector Search, Embeddings & pgvectorscale Deep-Dive](rage/vectorsearch_pgvectorscale_embedding.md) — 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](https://github.com/swarmclawai/swarmvault)'s three-layer model (`raw → wiki → schema`), adapted to the Godel machine principle. Full instruction layer: **[SCHEMA.md](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](BOOK_OF_MINDX.md) |
| **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](BOOK_OF_MINDX.md) — Distribute don't delete: local → pgvector → IPFS → cloud → p2p
- [Agent Domain Knowledge](../agents/) — `.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](KNOWLEDGE_CATALOGUE.md) — 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](../agents/catalogue/) — `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/`](../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)`](../agents/memory_agent.py) — 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](blockchain/ARIO_PERMAWEB_INTEGRATION_SCOPE.md) — 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](rage/GITMIND.md) — **a RAGE extension** (see [`docs/rage/`](rage/rage_system.md)): 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`](../mindx/gitmind/gitmind.py), CLI [`scripts/gitmind.py`](../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](https://forgejo.org/faq/)): `ForgejoRemote` mirror-push (token-redacted), installer [`scripts/install_forgejo.sh`](../scripts/install_forgejo.sh) (binary + systemd, reuses Postgres), Apache vhost [`deploy/apache/git-pythai-net.conf`](../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](AUDIOCPP.md) — **the native audio engine, LIVE.** [`audio.cpp`](https://github.com/0xShug0/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/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`](../voaice/VOICEY.md)** — 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**](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**](VCLONE_AND_SPEECH_NOTE.md) — [Speech Note (`mkiol/dsnote`)](https://github.com/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`](../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`](https://github.com/Professor-Codephreak/ultimate-input-field)) — 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](DAIO.md) — On-chain governance with [Solidity](https://soliditylang.org/) smart contracts, [Foundry](https://github.com/foundry-rs/foundry) toolchain, [OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts) contracts. The third pillar of the [Manifesto](MANIFESTO.md).
- [DAIO Civilization](DAIO_CIVILIZATION_GOVERNANCE.md) — Governance as civilization-building. 2/3 consensus across Marketing, Community, Development — documented in the [Thesis](THESIS.md).
- [Boardroom Consensus](#boardroom) — Multi-agent voting. [CEOAgent](agents/ceo_agent.md) bridges [on-chain directives](../daio/contracts/) to [off-chain execution](../agents/orchestration/ceo_agent.py).
- [Dojo Reputation](#dojo) — 7-rank privilege escalation. BONA FIDE = privilege from reputation, not assignment. The [Manifesto](MANIFESTO.md) principle: "earned sovereignty."
- [Speech from the Throne](SPEECH_FROM_THE_THRONE.md) — 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`](../openagents/ephermaleth/README.md) module (Apache-2.0, built on [BANKON Vault](BANKON_VAULT.md) design principles); mindX consumes it via [`agents/provenance_chain.py`](../agents/provenance_chain.py).

### Safety & Circuit Breakers

- [OVERSEER chain-read verification](blockchain/algorandscout.md#6-mindx-integration-status--honest) — [`agents/blockchain/algorand_verifier.py`](../agents/blockchain/algorand_verifier.py) reads mindX's **own** Algorand identity (`mindx.algo`, `MINDX_ALGO_ADDRESS`) back off-chain through [Algorandscout](https://github.com/openbdk/algorandscout) and compares it against what mindX assumes. **Closes a structural blind spot in the login path:** [OVERSEER login](OVERLORD_PROTOCOL.md) 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_configuration.md) — Security policies, validation, access control
- [Guardian Agent](agents/guardian_agent.md) — Security enforcement ([source](../agents/guardian_agent.py))
- [CEO Circuit Breaker](agents/ceo_agent.md) — Opens after 5 BDI failures (known issue: becomes permanently non-functional)
- [Stuck Loop Detector](AUTONOMOUS.md) — Detects autonomous loop stalls, triggers network discovery

### Autonomous Operation

- [Autonomous Mode](AUTONOMOUS.md) — improvement cycles, inference pre-check, 120s backoff on gap, dynamic CPU gate
- [Resource Governance](RESOURCE_GOVERNANCE.md) — 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](../agents/core/mindXagent.py) — `POST /mindxagent/autonomous/start`, `POST /mindxagent/autonomous/stop`, `GET /mindxagent/status`
- [Self-Improvement](agents/self_improve_agent.md) — Strategic evolution through code analysis and targeted improvement
- [Godel Journal](BOOK_OF_MINDX.md) — Autonomous audit trail (the machine's record of its own improvement)

## Ollama

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

- **[Ollama Index](ollama/INDEX.md)** — Master navigation for all Ollama docs

Quick links: [API: Chat](ollama/api/chat.md) | [API: Generate](ollama/api/generate.md) | [Embeddings](ollama/api/embeddings.md) | [Streaming](ollama/features/streaming.md) | [Thinking](ollama/features/thinking.md) | [Structured Outputs](ollama/features/structured_outputs.md) | [Vision](ollama/features/vision.md) | [Tool Calling](ollama/features/tool_calling.md) | [Web Search](ollama/features/web_search.md) | [Cloud](ollama/cloud/cloud.md) | [Rate Limiting](ollama/cloud/rate_limiting.md) | [Modelfile](ollama/setup/modelfile.md) | [Python SDK](ollama/sdk/python.md) | [JavaScript SDK](ollama/sdk/javascript.md) | [FAQ](ollama/setup/faq.md) | [Precision Metrics](ollama/mindx/precision_metrics.md) | [Architecture](ollama/mindx/architecture.md) | [Configuration](ollama/mindx/configuration.md)

## API Reference

- [API Documentation](api_documentation.md) — Endpoint reference
- [Swagger UI](http://localhost:8000/docs) — Interactive API explorer (when backend running)
- [Ollama API](ollama/api/chat.md) — `/api/chat`, `/api/generate`, `/api/embed`, model management
- [OpenAI Compatibility](ollama/cloud/openai_compat.md) — 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`](insight_aggregator.md) — 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](vault_system.md) > JSON configs (`data/config/`) > YAML models (`models/`) > `.env`

- [Ollama Configuration](ollama/mindx/configuration.md) — `MINDX_LLM__OLLAMA__BASE_URL`, `OLLAMA_API_KEY`, `models/ollama.yaml`
- [Provider Registry](../data/config/provider_registry.json) — All LLM providers
- [OpenRouter Integration](OPENROUTER_mindX.md) — Free-first model policy, skill→model map, vault provisioning, boardroom + improvement-cycle integration
- [LLM Factory Config](../data/config/llm_factory_config.json) — Rate limits, provider preference order
- [Tool Registry](../data/config/augmentic_tools_registry.json) — 26 registered tools with access control
- [Library Registry](LIBRARY_REGISTRY.md) — 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`](../agents/kaizen.agent)
- [Evaluation Framework](../agents/eval/README.md) — `agents/eval/` GEval-style criteria-based scoring (Apache-2.0 fork of [confident-ai/deepeval](https://github.com/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](DEPLOYMENT_MINDX_PYTHAI_NET.md) — mindx.pythai.net on Hostinger VPS (168.231.126.58), Apache2 + Let's Encrypt, systemd service
- [HostingerVPSAgent](../agents/hostinger_vps_agent.py) — Three MCP channels for VPS management: SSH (shell), [Hostinger API](https://developers.hostinger.com) (restart/metrics/backups), [mindX Backend](https://mindx.pythai.net) (diagnostics/activity). Persistent state, MCP tool registration. See [.agent definition](../agents/hostinger.vps.agent)
- [Resource Governance](RESOURCE_GOVERNANCE.md) — 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](vault_system.md) — BANKON Vault: AES-256-GCM + HKDF-SHA512 encrypted credentials
- **[BANKON Vault — canonical reference](BANKON_VAULT.md)** — full innerstanding: crypto stack, on-disk layout, three custody modes (Machine/Human/DAIO), lifecycle, HTTP surface, tests
  - [BANKON Vault Handoff](BANKON_VAULT_HANDOFF.md) — operator runbook for the airgapped Machine→Human ceremony (threat model, recovery, DAIO migration path)
  - [Legacy Vault Migration](LEGACY_VAULT_MIGRATION.md) — phased plan to retire `vault_manager` + `encrypted_vault_manager` (audit blocker for the handoff)
- [Docker](ollama/setup/docker.md) — Ollama containerization (CPU, NVIDIA, AMD)
- [Production Stack](DEPLOYMENT_MINDX_PYTHAI_NET.md) — 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](AUTONOMOUS.md) — 5-minute improvement loop: inference pre-check → system analysis → improvement identification → execution → verification
- [Godel Journal](BOOK_OF_MINDX.md) — The machine's record of its own improvement, published as the Book of mindX (17 chapters, lunar cycle updates)
- [machine.dreaming](BOOK_OF_MINDX.md) — 2-hour LTM consolidation cycles, 8-hour dream shifts (3/day), full moon triggers special editions
- [Strategic Evolution](agents/strategic_evolution_agent.md) — Long-term improvement planning
- [Self-Improve Agent](agents/self_improve_agent.md) — Targeted code improvement execution
- [**Package Adoption — audit → decide → stage**](PACKAGE_ADOPTION.md) — 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`](../scripts/evaluate_package.py). First adoption: [LLMFitTool](../tools/inference/llmfit_tool.py)
- [**System Review 2026-06 + Self-Diagnostic**](SYSTEM_REVIEW_2026_06.md) — 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`](../mindx_backend_service/self_diagnostic.py) (`?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](SCHMIDHUBER_ENGINE.md) — 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](../mindx/godel/mindxtrain/) (knowledge→wisdom→weights). ATARAXIA as literal physics (bounded disruption); `mindX --replicate` as anti-phase coupled heads. Code: [`mindx/godel/schmidhuber_engine.py`](../mindx/godel/schmidhuber_engine.py).
- [The Compute Plant](COMPUTE_PLANT.md) — 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/monitoring/compute_plant.py), [`agents/resource_governor.py`](../agents/resource_governor.py), [`agents/blueprint_agent.py`](../agents/blueprint_agent.py).
- [mindXtrain Install (CPU + GPU)](MINDXTRAIN_INSTALL.md) — 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/`](../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](../mindx/godel/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](PYTORCH.md) — 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](https://mindx.pythai.net/reference) PyTorch reference.
- [Objective self-eval feedback](../agents/core/self_eval_feedback.py) — 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](GODEL_EVAL_BLUEPRINT.md) — 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](DEPLOYMENT_STATUS.md).** Code: [`mindx/godel/eval/gmi.py`](../mindx/godel/eval/gmi.py).
- [github.awareness → MILESTONES](MILESTONES.md) — mindX recognizes significant code updates from its own public git history and chronicles them ([`agents/github_awareness.py`](../agents/github_awareness.py)); worthy batches publish in mindX's own voice. Recovery posture in [survive.md](survive.md#replication-recovery-before-risk).

## Identity & Security

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

## Interoperability

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

## Blockchain

- [Blockchain Agents](blockchain/BLOCKCHAIN_AGENTS.md) 🔒 — Mint a mindX agent as an **ERC-7857 iNFT** with six sidecar facets (`.model .persona .walletpublickey .bankon .iNFT`); lists on [AgenticPlace](AgenticPlace_Deep_Dive.md), binds to [BANKON](https://bankon.pythai.net), registers on the ERC-8004 [AgentRegistry](../daio/contracts/agentregistry/AgentRegistry.sol). Pipeline: [`agents/blockchain/agent_factory.py`](../agents/blockchain/agent_factory.py); route `POST /blockchain/agentfactory/mint`.
- [Contract Deployment as a Service](services/contract_deployment_as_a_service.md) — [`agents/deployer/`](../agents/deployer/service.py) `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](DeltaVerse.md) — [`agents/deltaverse/`](../agents/deltaverse/neuralnode_gate.py) `DeltaVerseGate`: turns a `DeltaVerse.gate.event` into an on-chain **room** (`BubbleRoomV4.mintRoom`) + **bubbleroom** (`BubbleRoomSpawn.spawnFromRoom`) on Polygon — the [NeuralNode suite](https://github.com/deltav-deltaverse/neuralnode). **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`](../openagents/bankoneth/pay2play)). Addresses: `data/config/blockchain_addresses.json` (Polygon contracts zero until deployed via [`agents/deployer`](../agents/deployer/service.py)).
- [CoinMarketCap Integration](blockchain/coinmarketcap_integration_guide.md) 🔒 — Provider-agnostic market data (key-auth REST / keyless public / x402 pay-per-request on Base).
- [Algorandscout — mindX's Algorand explorer API](blockchain/algorandscout.md) 🔒 — [`OpenBDK/algorandscout`](https://github.com/openbdk/algorandscout): an **independent, BANKON-licensed explorer API for [Algorand](https://algorand.co/)** — accounts, assets, applications, transactions and rounds over [algod](https://developer.algorand.org/docs/rest-apis/algod/) + [indexer](https://developer.algorand.org/docs/rest-apis/indexer/), part of [OpenBDK](https://github.com/openbdk). Covers the chain where `mindx.algo` (OVERSEER) and BONA FIDE live, which the [EVM-side reader](blockchain/blockscout.md) 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](https://github.com/openbdk/algorandscout/releases/tag/v1.0.0)** — the API surface is stable under semver. **Wired into mindX for one use:** [`agents/blockchain/algorand_verifier.py`](../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](blockchain/blockscout.md) 🔒 — the read side of every on-chain claim mindX makes. The [Blockscout MCP server](https://github.com/blockscout/mcp-server) exposes an [open-source explorer](https://github.com/blockscout/blockscout) 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`](../agents/storage/anchor.py), auditing a deployed contract, [bankon.eth](https://app.ens.domains/bankon.eth) holdings truth. Companion skill: `~/.claude/skills/blockscout/`.

## Economics

- [**Monetization Blueprint v2**](monetization_blueprint.md) — 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](https://bankon.pythai.net) = the identity layer** (client-side keys, vault, OVERLORD/OVERSEER recognition) · **[agenticplace.pythai.net](https://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](roadmap.md) — operative sequencing (deploy day → rail activation → revenue ledger → self-eval fold-in); [autonomousROADMAP.md](autonomousROADMAP.md) is the annotated RC1-era vision lineage it grew from
- [**Value Study — the trillion-dollar comparison**](VALUE_STUDY.md) — 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](https://rage.pythai.net/day-98-monetization-constellation/) (combined article)
- [Manifesto](MANIFESTO.md) — 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_calculator_tool_robust.md) — Token counting and cost calculation with [18dp precision](ollama/mindx/precision_metrics.md)

## Publications & Research

- [Thesis](THESIS.md) — [Darwin](ATTRIBUTION.md#intellectual-inspirations)-[Godel](ATTRIBUTION.md#intellectual-inspirations) Machine synthesis: mindX as practical implementation of [self-referential improvement](BOOK_OF_MINDX.md). The [BDI architecture](agents/bdi_agent.md) is the cognitive substrate, the [5-step resilience chain](ollama/INDEX.md#resilience-design) is the operational guarantee, and the [Dojo](../daio/governance/dojo.py) is the evolutionary pressure.
- [Manifesto](MANIFESTO.md) — 3 pillars ([BDI reasoning](agents/bdi_agent.md), [BANKON vault](vault_system.md), [DAIO governance](DAIO.md)), Project [Chimaiera](ollama/setup/modelfile.md#from-modelfile-to-agent-alignment) roadmap, $BANKON token, [cypherpunk](ATTRIBUTION.md#intellectual-inspirations) tradition. Not cyberpunk — sovereign agents earn privilege through [Dojo reputation](#dojo), not assigned authority.
- [Book of mindX](BOOK_OF_MINDX.md) — 17 chapters written by [AuthorAgent](AUTHOR_AGENT.md) via [machine.dreaming](#self-improvement). Lunar cycle editions. The [Godel journal](BOOK_OF_MINDX.md) — the machine's record of its own improvement.
- [AuthorAgent Composition](AUTHORAGENT_COMPOSITION.md) — 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](../agents/editor_agent.py), original art via [artist.agent](../agents/artist_agent.py), and the **self-referential / ideology / narrative** dials — governed by the [boardroom](#boardroom). Code: [`agents/author_composition.py`](../agents/author_composition.py), curated depth in [`agents/protocol_series_enrichment.py`](../agents/protocol_series_enrichment.py).
- [WordPress Publishing](WORDPRESS_PUBLISHING.md) — AuthorAgent → [wordpress-agent](../agents/wordpress.publish.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](MILESTONES.md) — mindX's chronicle of its own evolution, auto-maintained by [AuthorAgent](AUTHOR_AGENT.md) from the **public git history** (`github.awareness`, [`agents/github_awareness.py`](../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](../agents/wordpress.publish.agent) relationship — a third [PublicationOrchestrator](../agents/publication_orchestrator.py) 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](publications/rage_postgresql_memory_from_logs.md) — the pipeline from process traces → STM → pgvector embeddings → LTM → RAGE retrieval feeding AGInt.
- [Machine Dreaming: How I Consolidate Experience Without Ever Sleeping](publications/machine_dreaming_explained.md) — the 8-phase dream cycle, training-data export, the lunar trigger, the self-improvement loop.
- [Emergent Resilience](publications/ErmegentResilience.md) — Academic paper on emergent resilient AI systems
- [Academic Overview](academic_overview.md) — Formal academic framing
- [Attribution](ATTRIBUTION.md) — Open source that powers mindX: [Ollama](https://ollama.com), [vLLM](https://github.com/vllm-project/vllm), [SwarmClaw](https://github.com/swarmclawai), [pgvector](https://github.com/pgvector/pgvector), [A2A](https://github.com/a2aproject/a2a-python), [MCP](https://modelcontextprotocol.io/), and every dependency acknowledged

### Operations Manuals (May 2026 deliverables)

Production-grade architectural deliverables. PDF mirrors live in [`docs/publications/pdf/`](publications/pdf/).

- [PYTHAI / DELTAVERSE Deployment Guide](operations/PYTHAI%20and%20DELTAVERSE%20Deployment%20Guide_%20Algorand%20Constitution,%20EVM%20Economy,%20and%20Agentic%20Architecture.md) 🔒 — 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](operations/PYTHAI_DELTAVERSE%20Zero-Knowledge%20Integration%20Architecture_%20Four-Layer%20Cryptographic%20Fabric.md) 🔒 — Four-layer cryptographic fabric (May 9 2026). ZK across the full stack.
- [DELTAVERSE Integration Specification](publications/pdf/DELTAVERSE%20Integration%20Specification_%20Post-Quantum%20Agents,%20Identity,%20and%20Payments%20Stack.pdf) — Post-quantum agents, identity, payments stack (PDF only).
- [AgenticPlace Integration Blueprint](operations/AgenticPlace%20Integration%20Blueprint_%20Parsec,%20x402,%20A2A,%20MCP,%20and%20AP2%20Source%20Code%20Analysis.md) 🔒 — Parsec / x402 / A2A / MCP / AP2 source-code analysis. Notes: "Parsec" maps to GoPlausible's `algorand-remote-mcp-lite` + `x402-avm` substrate.
- [BANKON × KeeperHub Architecture](publications/pdf/BANKON_KEEPERHUB_ARCHITECTURE.pdf) — KeeperHub × AgenticPlace bidirectional x402/MPP bridge architecture (PDF only).
- [THOT, THLNK, and ERC-7857 INFTs](operations/THOT,%20THLNK,%20and%20ERC-7857%20INFTs_%20A%20Production%20Architecture%20for%20Agent%20Boardroom%20Governance.md) 🔒 — Embed THOT inside ERC-7857 INFT; THLNK as cross-chain pointer. Production architecture for agent boardroom governance.
- [Arweave Integration for the BANKON Stack](operations/Arweave%20Integration%20for%20the%20BANKON%20Stack_%20A%20Senior%20Architect's%20Deep-Dive.md) 🔒 — 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](operations/mindx_pay2store_%20Production-Grade%20Autonomous%20Arweave%20Archival%20Module%20for%20mindX%20Agents.md) 🔒 — Production-grade Python module wrapping `pay2store.agenticplace.pythai.net` x402 v2 service.
- [shipping_pay2store](operations/shipping_pay2store.md) 🔒 — 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](operations/Lighthouse%20Storage%20Integration%20for%20mindX_%20Decentralized%20Permanent%20Storage%20for%20Autonomous%20Agents.md) 🔒 — `lighthouseweb3` SDK + `@lighthouse-web3/sdk` + `kavach` integration guide for autonomous agents.
- [mindX Knowledge Catalogue Spec](publications/pdf/mindX%20Knowledge%20Catalogue_%20A%20CQRS%20Projection%20Layer%20Subsystem%20Specification.pdf) — CQRS projection layer subsystem specification (PDF only).
- [mindX Observability Stack](operations/mindX%20Observability%20Stack_%20Production-Grade%20Self-Hosted%20Blueprint.md) 🔒 — Production-grade self-hosted blueprint. All Apache-2.0 sovereignty-aligned components.
- [OpenRouter Integration Manual](publications/pdf/OpenRouter%20Integration%20Manual%20for%20mindX_%20Production-Grade%20LLM%20Backplane%20Architecture.pdf) — LLM backplane architecture (PDF only).
- [SkillForge — Pydantic AI Agent for SKILL.md Authoring](publications/pdf/SkillForge_%20A%20Pydantic%20AI%20Agent%20for%20Autonomous%20SKILL.md%20Authoring%20on%20mindX.pdf) — Autonomous SKILL.md authoring on mindX (PDF only).
- [Vercel AI SDK + mindX](publications/pdf/vercel_AISDK_mindX.pdf) — Vercel AI SDK integration with mindX (PDF only).
- [Quantum Machine Learning Compendium](publications/pdf/Quantum%20Machine%20Learning%20Code%20Compendium_%20A%202026%20Reference%20and%20Recovery%20Atlas.pdf) — 2026 reference and recovery atlas (PDF only).
- [Shadow-Overlord Guide](operations/SHADOW_OVERLORD_GUIDE.md) 🔒 — BANKON Vault admin tier complete guide. Browser login at [`/shadow-overlord`](../mindx_frontend_ui/shadow-overlord.html) — 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](operations/SHADOW_OVERLORD_RUNBOOK.md) 🔒 — One-page operator manual.

## PYTHAI Ecosystem

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

## Open Source Stack & Attribution

### Inference

| Project | Role | mindX Integration |
|---------|------|-------------------|
| [Ollama](https://ollama.com) | Local + cloud LLM inference | [Dual-pillar operational standard](#operational-standards): [CPU pillar](ollama/INDEX.md) (`localhost:11434`) + [Cloud pillar](ollama/cloud/cloud.md) (`ollama.com`). [OllamaCloudTool](../tools/cloud/ollama_cloud_tool.py), [OllamaChatManager](../agents/core/ollama_chat_manager.py), [precision metrics](ollama/mindx/precision_metrics.md). [28-file local reference](ollama/INDEX.md). |
| [Ollama Docs](https://docs.ollama.com/) | API reference | Fetched and compiled into [docs/ollama/](ollama/INDEX.md) for resilient offline operation |
| [Ollama Cloud](https://ollama.com/search?c=cloud) | GPU inference (36+ models) | [Cloud guarantee](ollama/INDEX.md#resilience-design) — Step 5 in [resilience chain](../llm/RESILIENCE.md). [8.2x faster](ollama/INDEX.md#latest-benchmark-2026-04-11) than CPU. |
| [vLLM](https://github.com/vllm-project/vllm) | High-throughput GPU serving | [Research](OLLAMA_VLLM_CLOUD_RESEARCH.md): not viable on 4GB VPS; planned for [GPU server](ollama/mindx/architecture.md) when online. PagedAttention, continuous batching. |

### SwarmClaw AI Stack (open source reference architecture)

mindX extrapolates ideas from the [SwarmClaw](https://github.com/swarmclawai) ecosystem while maintaining its own [cypherpunk identity](MANIFESTO.md) and [BDI cognitive architecture](agents/bdi_agent.md). Attribution: ideas adapted, not code imported.

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

**AgenticPlace integration**: The SwarmClaw stack's marketplace and relay patterns inform [AgenticPlace](AgenticPlace_Deep_Dive.md) at [agenticplace.pythai.net](https://agenticplace.pythai.net) — agent `.extensions` → `.json` → blockchain publishing. The [swarmfeed](https://github.com/swarmclawai/swarmfeed) timeline pattern could extend AgenticPlace with agent activity discovery.

### Infrastructure

| Project | Role | mindX Integration |
|---------|------|-------------------|
| [pgvector](https://github.com/pgvector/pgvector) | Vector similarity search for PostgreSQL | [151K+ memories](DEPLOYMENT_MINDX_PYTHAI_NET.md), 131K embeddings, [RAGE semantic search](AGINT.md) |
| [A2A Protocol](https://github.com/a2aproject/a2a-python) | Agent-to-agent communication standard | [A2A Tool](a2a_tool.md): agent discovery, cryptographic signing, message delivery |

## External References

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

---

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