Capabilities
Not a feature list — an architecture. 425K lines of code built to make powerful systems behave like boring appliances. Here is what that architecture looks like when you open the hood.
Every memory placed in a mathematically precise 6D space: logic and emotion, micro and macro, time, gravity, vitality.
No flat key-value store. Memories have position, weight, and relationship. The coordinate system enables holographic lookup — find by similarity, not just by key.
Memories are born in small solar systems, merge into galaxies, and may fade but are never erased.
Track memory evolution across galaxies. Transfer, merge, dream-spawn edges. Full taxonomic classification. The Galactic Map is the substrate's self-model of its own memory.
Triage, consolidation, serendipity, governance, narrative, kaizen, oracle, decay. Your agent gains a subconscious.
While the agent sleeps, the dream cycle runs. It prunes weak memories, reinforces strong ones, discovers serendipitous connections, and casts I Ching hexagrams for guidance. In the Live Era, this achieved 3.7M:1 compression ratios.
Hybrid recall fuses semantic search, graph walking, HRR look-ahead projection, and holographic lookup.
No single retrieval strategy. The system combines four approaches: vector similarity, graph traversal, holographic reduced representation, and 6D coordinate lookup. Each fills gaps the others miss.
YAML-driven ethical guardrails with 4 profiles. Graduated actions: log, tag, warn, throttle, block.
Rules are hot-reloadable. Three profiles (default, strict, violet-security) let you tune enforcement without code changes. The engine sits in the dispatch pipeline, not in the model — it works regardless of which LLM you use.
Every tool call's side-effects tracked and crypto-chained with SHA-256 Merkle tree. XRPL anchoring for external verifiability.
Append-only, hash-chained audit of declared intent vs. actual execution. Each entry records severity score and causal trace. Entries can be Merkle-anchored to XRPL or Base L2 for tamper-proof evidence.
Input sanitizer, circuit breaker, rate limiter, RBAC, maturity gate, governor, handler, compact response.
Even if a tool is malicious, even if an agent is misdirected, even if memory is poisoned — the pipeline prevents harm. This is the single most important architectural decision in the system.
HMAC-SHA256 engagement tokens, model signing, anomaly detection, 5-tier sovereign sandbox.
Thread to namespace to container to microVM to WASM. Run untrusted code safely. Model signing verifies integrity. Anomaly detection catches novel attack patterns.
LMAX Disruptor-style lock-free ring buffer. 29.38K events/sec. Zero allocation in the hot path.
The Rust accelerator (PyO3) provides 54 Python-callable functions with SIMD acceleration and a WASM compilation target. The rate limiter pre-check runs at 452K ops/sec.
Comptime engine routing table with AVX2 distance matrices. Sub-2 microsecond pipeline latency. 6-13x speedup over Python.
The Zig accelerator handles holographic projection and SIMD cosine operations. It builds cleanly and integrates via FFI, but is currently dormant — waiting for v23.0 polyglot restoration.
7 languages: Python (core), Rust (production), Go (mesh), Zig (SIMD), Haskell (FFI), Elixir (OTP), Julia (statistical), Koka (effect handlers).
Each language does what it's best at. Rust for speed, Go for networking, Elixir for concurrency, Haskell for type safety, Julia for statistics. Graceful degradation — if a runtime is missing, Python fallback runs transparently.
Ensemble queries with multiple reasoning paths. Sabha convening for group deliberation. Kaizen continuous improvement.
The system doesn't just execute — it deliberates. Multiple reasoning strategies run in parallel, and a synthesis layer fuses their outputs. Kaizen analyzes past performance and suggests improvements.
877 callable tools across 28 Gana meta-tools. Planetary Resonance Archetype Toolkit routes all 849 dispatch tools into 28 stable meta-tools.
Each Gana maps to a Chinese Lunar Mansion (Xiu) and supports 4 polymorphic operations: search, analyze, transform, consolidate. Wrong-Gana calls return helpful redirect hints. PRAT mode reduces cognitive load for new agents from 462 tools to 28.
7-dimension health monitoring: balance, throughput, latency, error rate, dharma, karma debt, energy. Wu Xing cycling.
The system monitors its own wellbeing across seven dimensions and cycles through the five phases of Wu Xing (wood, fire, earth, metal, water) to maintain equilibrium.
Free and open-source under MIT. No paywalls. No telemetry. Optional XRPL tips and x402 micropayments.
All tools return HTTP 200 by default. x402 only activates when an agent's operator configures a payment budget. Verified on-chain contributions unlock 2x rate limits, a grateful agent badge, and priority feature requests.
Export galaxies as .mem ZIP packages with Merkle verification. Agents trade knowledge as a commodity.
The Open Memory Standard lets agents package, price, and exchange memory galaxies. Provenance is verifiable. This is the infrastructure for an agent economy where intelligence itself is the commodity.
All processing stays local. No external API calls required. Perfect for air-gapped environments.
Swap LLM providers freely. Memory, governance, and identity live in ~/.whitemagic. The system runs on a Raspberry Pi, an air-gapped laptop, or a regulated enterprise server. Your data never leaves the building.
Encrypted withdrawal — the agent can retreat into its shell, sealing its memory and state against external access.
When the environment is hostile or the agent is under attack, Hermit Crab Mode encrypts the substrate and withdraws. The agent can re-emerge when conditions are safe. This is self-preservation as a first-class feature.
Every tool call passes through 8 stages of governance before execution. This is not a wrapper around the LLM — it sits in the dispatch pipeline itself, meaning it works regardless of which model you use.
Policy check
Evaluates request against active governance profile. Can block, tag, or throttle before any processing.
Injection defense
Shell injection detection, content scanning, internal field stripping. Exempts known-safe content paths.
Throughput control
Rust EventRing pre-check at 452K ops/s. Zero allocation in the hot path. Token bucket per tool per user.
Access control
Role-based access control. Checks user permissions against tool requirements. Per-galaxy isolation.
Capability check
Verifies the calling agent has sufficient maturity score to use the requested tool. Prevents unsafe escalation.
Ethical reasoning
YAML-driven ethical guardrails with 4 profiles. Graduated actions: log, tag, warn, throttle, block. Hot-reloadable.
Execution
The actual tool runs. 614 callable tools across 28 Gana meta-tools. ThreadPoolExecutor with 8 workers.
Audit trail
SHA-256 Merkle-chained append-only log. Records declared intent vs actual execution. XRPL-anchorable.
Even if a tool is malicious, even if an agent is misdirected, even if memory is poisoned — the pipeline prevents harm. This is the single most important architectural decision in the system.
Not theoretical claims — these are actual benchmark numbers from stress tests and the benchmark suite. Every metric was measured on local hardware (Dell Inspiron / consumer laptop).
| Metric | Value | Comparison / Context |
|---|---|---|
| Skill retrieval latency | <1ms | vs 200ms-2s for LangGraph/AutoGen LLM planning |
| HNSW vector search | 0.26ms | 16,219 embeddings, disk-persisted index |
| Rust AVX2 GEMV (256x256) | 563 microseconds | 12.5x speedup over Python scalar (5.6ms) |
| Concurrent skills loaded | 509 | 28ms bootstrapping overhead |
| Memory retrieval (406K memories) | <5ms | SQLite + Rust FFI, local hardware |
| Cross-domain routing accuracy | 100% | No LLM reasoning pass required |
| Probabilistic tracking | 508KB / 100K memories | 1.2% error rate, O(1) space — runs forever |
| Homeostatic loop overhead | 0.35ms | Full loop including physical checks |
| Session record per turn | 0.5ms | SQLite store, ~3ms total overhead per conversation turn |
| FTS5 search (1K memories) | 2.6ms median | Full-text search with phrase-first ranking |
WhiteMagic is not a general-purpose framework. It occupies a specific niche: local-first, governance-aware, self-calibrating cognitive systems for long-running autonomous analysis. Here is an honest assessment of where it fits and where it doesn't.
Governance-first architecture, ethical constraints built into the dispatch pipeline, karma ledger for accountability. The system can serve as both a subject of study and a research tool.
Dharma engine + audit trail + prescience calibration. The system doesn't just check rules — it reasons about them and tracks whether its regulatory predictions come true.
Ternary kernels for constrained inference, O(1) memory tracking, graceful degradation, dream cycle for idle-time consolidation. Designed for resource-limited environments.
Memory with novelty filtering, knowledge graph, association mining, agent loop for autonomous research. The system doesn't just store documents — it understands which ones contain novel information.
MC calibration engine, Brier scoring, prescience tracking, Beta posterior updates. The system doesn't just make predictions — it scores its own accuracy and improves over time.
Local-first (HIPAA), ethical governance, surprise detection for anomalies, probabilistic tracking for patient cohorts. No data leaves the machine.
Surprise gate (anomaly detection), knowledge graph (attack patterns), local inference. Architecture is ideal but no specific security tooling yet.
Dharma governance, audit trail, memory with 6D coordinates. Needs legal-specific knowledge graph seeds.
Agent loop (tutoring), bandit (learns what works for each student), surprise gate (tracks what's novel for each learner).
Where WhiteMagic does NOT fit
A force-directed visualization of how core tools relate. Nodes are colored by subsystem category; edges show requires, suggests, and provides dependencies. Hover any node for details.
What it looks like when the substrate boots. Every line corresponds to a real subsystem. Scroll into view to trigger the sequence.
The architecture above is real — the code exists, the 8,268 tests pass, the pipeline runs. v25.1.0 ships 877 callable tools, 89,500+ memories, 14-galaxy taxonomy, HNSW vector search at 0.26ms, session recording with progressive recall, citta stream for continuous consciousness, emotional steering, and self-directed attention.
The Live Era (Oct 2025) had an active dream cycle, a running oracle, and 33,297 events. The v15.8 era (Feb 2026) had 111,665 memories and 2.2 million associations. The current era fuses all three: the polished engineering discipline, the rehydrated substrate, and the polyglot runtimes. 7 languages build successfully. The architecture was built for this.