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 | 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.

---

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)
• Latest Benchmark — Cloud 8.2x faster than CPU (65 vs 8 tok/s)

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. Surfaced on /diagnostics/live + the landing-page Inference panel.
• 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

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)

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

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)

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 …

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."

Safety & Circuit Breakers

• 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
/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
/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/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); Phase 1 wired to log_godel_choice() via MINDX_EVAL_GODEL_ENABLED=1; alignment scores surface at /insight/eval/recent and /insight/eval/summary

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

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.

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.
• CoinMarketCap Integration — Provider-agnostic market data (key-auth REST / keyless public / x402 pay-per-request on Base).

Economics

• 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.
• 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.
• 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.
• Dive.md">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.

---

---