Wikantik is an agent-grade technical knowledge platform — engineered simultaneously for human deep reading and native AI agent retrieval, graph traversal, and software engineering coordination. Every page is stored as structured Markdown with validated YAML frontmatter, rename-safe ULIDs (canonical_id), and explicit cluster declarations.

Core Platform Capabilities

• Dual-Graph Architecture (Page Graph + Knowledge Graph): Browse 91 topic clusters and sub-clusters anchored by curated Hub pages (Cluster Declaration Architecture). Explore structural relationships through the Page Graph of bidirectional wikilinks and the Knowledge Graph of extracted entities, relationships, and formal OWL/SKOS SPARQL ontology.
• Hybrid Contextual Retrieval (/knowledge-mcp — 22 read-only tools): Queries execute across BM25 lexical and dense vector indices fused via Reciprocal Rank Fusion (Hybrid Retrieval), with contextual chunk headers (Cluster + Title + Summary + Heading Path). Agents assemble version-pinned, citation-bearing bundles via assemble_bundle and inspect provenance-scored projections (AUTHORITATIVE / PROVISIONAL / STALE) via get_page_for_agent.
• Closed-Loop Content Intelligence (/wikantik-admin-mcp — 29 read/write tools): Curators and agents author pages with optimistic locking (update_page), run 7-dimension structural/SEO/retrieval verification (verify_pages), curate Knowledge Graph nodes and edges (curate_nodes, curate_edges), and act on search-telemetry demand signals (list_content_opportunities via Content Intelligence).

Software Engineering & Multi-Agent Development Workflows

Beyond serving as a reference library, Wikantik acts as the active architectural control plane for ongoing software development across multiple repositories (Simple Agility Stack Hub):

1. Tiered Session-Start Briefings (get_briefing / SA-13): Rather than relying on static repo-local prompt files that silently drift out of date, coding agents start every session by calling get_briefing(clusters=["<project>"], prompt="<task>") (Project Context Separation Design). The wiki dynamically assembles three tiers of context: the project's core architecture pages (ranked by intra-cluster in-degree), the cross-project contracts that project cites (Architectural Decision Log, Telemetry Contract, Agent Coordination), and task-matched sections — while isolating operational incident runbooks from standing coding context.
2. Design-First RFCs & Cross-Repository Contract Propagation: System designs (type: design), RFCs, and cross-repo API/telemetry contracts live in the wiki as versioned, link-verified specifications (Context Engineering for Coding Agents). When a shared contract is updated, every downstream repository whose Hub cites that contract automatically receives the updated specification on its next session briefing.
3. Scenario-Keyed Engineering & Incident Runbooks (type: runbook): Recurring engineering playbooks — exploring module API surfaces, running parallel integration test reactors, planning schema migrations, or triaging production alerts — are encoded as structured runbooks (when_to_use, steps, pitfalls) in the Agent Cookbook and infrastructure hubs (Home Lab Infrastructure Hub), ready for on-demand agent execution.
4. Living Documentation & Verification Loops: As code changes land or incidents are resolved, coding agents update the corresponding architecture pages and runbooks in the same workflow (update_page → verify_pages → mark_page_verified), keeping design documentation, Knowledge Graph entities, and production implementation continuously aligned (Agentic Coding Hub).

New here? Start with About for the platform manifesto, the Wikantik Platform Hub for system internals, the Agent Cookbook for operational agent runbooks, or the Simple Agility Stack Hub for cross-project engineering workflows. You can also read the site blog.

Article Clusters

Wikantik Platform, Agent Workflows & Architecture

• Wikantik Platform Hub — Master index for the Wikantik platform: hybrid BM25 + vector search, dual Page/Knowledge Graphs, MCP servers, and React SPA architecture
• Wikantik System Architecture — End-to-end engineering architecture: multi-module reactor, hybrid file + PostgreSQL/pgvector storage, retrieval pipeline, and MCP agent surface
• Wikantik Platform Development Hub — Active engineering specifications, ADRs, MCP authoring conventions, observability, and release/deployment runbooks
• Agent Cookbook — Scenario-keyed operational runbooks for AI coding agents: retrieval gating, session briefings, KG curation, testing, and codebase navigation
• Simple Agility Stack Hub — Cross-project architectural spine connecting Wikantik, JakeMon observability, Roller, Stockroom, and multi-agent coordination contracts
• Page Graph vs. Knowledge Graph — How Wikantik separates human-authored wikilink topology and Hub-declared clusters from machine-extracted entity/relation triples
• Hybrid Retrieval & Contextual Chunking — Operator and architectural reference for BM25 + dense vector retrieval, Reciprocal Rank Fusion, and contextual embedding headers
• Tiered Agent Session Briefings (SA-13) — How get_briefing assembles standing project context, cross-cluster contract citations, and prompt-refined sections while preventing incident noise

Agentic AI, Foundation Models & Machine Learning

• Agentic AI Hub — Cognitive architectures, perceive-reason-act control loops, MCP tool protocols, episodic/semantic memory, and multi-agent orchestration
• Agentic Coding Hub — Autonomous software engineering workflows: context engineering, verification loops, mutation testing, worktree isolation, and failure guardrails
• Generative AI Hub — Foundation model internals, Transformer attention mechanics, Retrieval-Augmented Generation (RAG), multimodal embeddings, and alignment
• AI Infrastructure Hub — GPU cluster interconnects, PagedAttention inference serving, vLLM/Triton engines, INT4/FP8 quantization, and distributed training
• Machine Learning Hub — Classical and modern ML engineering: supervised/unsupervised learning, gradient-boosted trees, anomaly detection, and MLOps pipelines
• Large Language Models Since 2020 — From GPT-3 and Chinchilla scaling laws to o1/R1 reasoning models, DeepSeek MoE/MLA, frontier multimodal agents, and test-time compute
• Generative AI Adoption Guide — Practitioner roadmap for adopting LLMs: model evaluation, structured prompting, local inference, and production workflow integration
• Embedded AI on Edge & Limited Hardware — Running quantized models on microcontrollers, edge NPUs, and workstations: TinyML, GGUF/llama.cpp, and on-device inference economics

Software Architecture, Distributed Systems & Computer Science

• Software Architecture Hub — Distributed systems topology, Domain-Driven Design (DDD), event sourcing, CQRS, cell-based architecture, and evolutionary trade-offs
• Distributed Systems Hub — Consensus protocols (Paxos, Raft), replication topologies, logical clocks, two-phase commit, saga patterns, and fault tolerance
• Software Engineering Practices Hub — Trunk-based development, code review rigor, testing pyramids, static analysis, refactoring discipline, and backwards compatibility
• Design Patterns Hub — Gang-of-Four creational, structural, and behavioral patterns evaluated for modern multi-paradigm and concurrent systems
• Programming Languages Hub — Comparative language architecture across Rust, C++, Go, Java, Python, Lisp, Smalltalk, Haskell, Erlang, and type-system evolution
• Computer Science Foundations Hub — Automata theory, formal grammars, compiler construction, operating system internals, and computational complexity (P vs. NP)
• Data Structures & Algorithms Hub — Cache-conscious trees (B+Trees, LSM-Trees), probabilistic structures (Bloom filters, HyperLogLog), graph algorithms, and amortized analysis
• Java Platform & JVM Internals Hub — Modern Java (21+), virtual threads (Project Loom), ZGC/G1GC garbage collection, JIT compilation, and enterprise build tooling
• Frontend Engineering Hub — Browser rendering pipelines, Web Components and Shadow DOM, state management, SSR/hydration, TypeScript, and Core Web Vitals
• Web Services & API Architecture Hub — REST, GraphQL, gRPC, WebSockets, API gateway rate limiting, idempotency keys, and schema evolution
• Foundational Algorithms Reference — Deep dive into sorting, shortest-path and network-flow graph algorithms, dynamic programming, and cryptographic primitives
• Thirty Years of Distributed Computing — From RPC and CORBA to cloud-native service meshes, durable execution engines, and modern observability

Cloud, DevOps, Security, Data Engineering & Infrastructure

• DevOps & Site Reliability Engineering Hub — SLIs/SLOs and error budgets, CI/CD deployment gates, OpenTelemetry observability, incident response, and chaos engineering
• Cloud Platforms & Architecture Hub — AWS, GCP, and Azure foundational primitives, VPC networking, serverless execution, FinOps cost optimization, and multi-region DR
• Cybersecurity, AuthN/AuthZ & Container Security Hub — OAuth 2.1/OIDC, Passkeys/WebAuthn, Zero-Trust mTLS, Linux container isolation (seccomp/eBPF), and cryptographic key management
• Computer Networking & Protocols Hub — OSI/TCP-IP stack, BGP routing, TLS 1.3 handshakes, HTTP/3 QUIC, high-performance kernel bypass (DPDK/XDP), and DNS architecture
• Data Engineering & Lakehouse Hub — Idempotent batch/streaming pipelines, Apache Kafka/Pulsar, Iceberg/Delta lakehouses, dbt transformations, and dimensional modeling
• Database Internals & Performance Hub — ACID isolation levels, MVCC lock contention, query planner optimization, connection pooling, and declarative partitioning
• Home Lab & Self-Hosted Infrastructure Hub — Production fleet topology, Cloudflare Zero Trust ingress, Docker host management, GPU inference nodes, and automated backup verification
• Linux Systems & Command-Line Guide — Linux kernel and filesystem hierarchy, POSIX permissions, systemd service management, package managers, and Bash scripting

Mathematics, Operations Research & Applied Engineering

• Mathematics for Computer Science & ML Hub — Linear algebra, multivariable calculus, measure-theoretic probability, abstract algebra, topology, and formal predicate/modal logic
• Operations Research & Mathematical Optimization Hub — Linear and mixed-integer programming (MILP), convex optimization, vehicle routing (VRP), queuing theory, and stochastic inventory models
• Warehouse Automation & Industrial Robotics Hub — High-density AS/RS kinematics, autonomous mobile robots (AMRs), WMS/WCS orchestration, sortation mechanics, and Lean/Six Sigma flow
• Physics & Mechanical Engineering Hub — Classical and Lagrangian mechanics, thermodynamics, differential geometry, general relativity, and non-destructive physical metrology
• Mathematical Foundations of Machine Learning — Matrix factorizations, automatic differentiation, information-theoretic divergence, and non-convex optimization landscapes

Personal Finance, Investing & Geopolitics

• Personal Finance & Tax Strategy Hub — Household balance-sheet optimization, marginal tax planning, debt amortization math, estate structures, and risk management
• Low-Cost Index Fund Investing Hub — Modern Portfolio Theory, factor exposure, tax-efficient asset location, tolerance-band rebalancing, and early retirement accumulation
• Retirement Decumulation & Income Guide — Safe withdrawal rates, sequence-of-returns mitigation, Roth conversion ladders, Social Security bend-point math, and ACA/Medicare thresholds
• European Retirement & Cross-Border Investing Guide — Three-pillar EU pension architecture, UCITS ETF taxation, and country-specific regulatory frameworks across Europe
• Geopolitics & Global Financial Markets Hub — Econometric analysis of sovereign debt cycles, commodity supply shocks, trade corridors, and equity drawdown recovery coefficients
• International Conflicts and Equity Markets — Historical market drawdowns, volatility regimes, and sector rotation patterns from WWI through modern geopolitical crises
• The Russia-Ukraine War: Strategic & Economic Analysis — Attrition dynamics, autonomous drone warfare, energy infrastructure targeting, sanctions routing, and defense-industrial scaling