Technical Wiki

The Digital Partner is a software ecosystem that gives AI a local, sovereign, verifiable memory. It does not replace LLMs — it complements them by providing local, persistent, tamper-proof, governed context. You talk to Tosio (the orchestrator), which relies on Swarm (memory), GPS-S (navigation), and Zero-LLM (inference) to record, retrieve, and certify every decision.

Operating cycle: during work sessions, the user talks to Tosio, which asks GPS-S to navigate the Swarm graph and retrieve relevant information. Outside work phases, Tosio drives a symbolic reconstruction of memories. This step detects and resolves frictions and conflicts, and recalibrates N3+1. When a contradiction cannot be resolved, Tosio escalates it to the user for validation (human in the loop).

📖 Full glossary →

In the Digital Partner ecosystem, Tosio is the orchestrator. It talks to the user, drives the other components (Swarm, GPS-S, Zero-LLM), enforces governance rules, and certifies every decision. Tosio includes a continuous learning capability — its efficiency improves over time, without your data ever being used to train the system.

Properties of the memory orchestrated by Tosio:

• Optimized — storage at minimal energy in memory nodes. Storage capacity is exponential (modern associative memories / Dense Associative Memories), practically bounded by the license tier (2,000 in Discovery, 2,000 in Essential, 10,000 in Extended, ≥ 20,000 in Exclusive)
• Tamper-proof — N3+1 computational topological invariant (i_topo ≥ 0.70, calibrated), named after the NLSE solitons studied by Tosio Kato: any alteration is detected and repaired automatically
• Provable — every decision is timestamped (SHA-256), chained, and anchored in the graph via a topological bridge. Verifiable without a trusted third party
• Indexed — per-user SHA-256 registry, interconnected memory nodes (multicausal, multidimensional network)
• Self-reconstructing — through topological recrystallization (a kind of digital DNA), memory repairs itself after corruption. This mechanism never uses your data to train the system: each user has their own isolated memory space via Multi-Swarm
• Infinite dimension — by topological construction, the graph can grow without architectural limits within the subscribed license tier

Swarm is the storage component of the ecosystem. The Swarm graph is built on an N3+1 topological invariant that guarantees its integrity.

The full memory properties are described in the Tosio section. In short: storage optimized by memory attractors, alteration detection through the N3+1 topological soliton, SHA-256 timestamped proofs, and self-repair through recrystallization — all without ever using your data to train the system (each license has an isolated memory space via Multi-Swarm).

Background: associative memory

An associative memory is a model where every stored pattern corresponds to a stable attractor. When a partial or noisy pattern is presented, the network converges by associative recall toward the closest complete pattern. In Swarm:

• Each storage node is a local attractor
• Recall starts from the context provided by Tosio and descends the energy gradient to the relevant memory
• Capacity is exponential (modern associative memories / Dense Associative Memories), practically bounded by the license tier

📐 Interactive 3D visualization of the Swarm graph → (Three.js, 10 KB)

GPS-S (Global Positioning Soliton — Semantics) is the navigation layer of the ecosystem. It does not store memories — it lets you find your way in the Swarm graph.

Analogy: Swarm is the city (the buildings are memories). GPS-S is both the topographic map (the 3D plan with every street, path, and building) and the GPS (what routes get you efficiently from A to B).

Functions

• Mapping — GPS-S maintains a map of the graph: which regions hold which types of memories, which paths are optimal
• Navigation — from the current context, GPS-S plots a route to the relevant memory
• Recalibration — after the metaphor phase (building a symbolic representation of memories), the GPS-S map is updated. On contradiction, Tosio asks the user

Modes

• Read/write in every offer (Discovery: 500 nodes, Essential: 300, Extended: 500, Exclusive: ≥ 500). Full multi-space navigation (Extended+)

N3+1 is the computational topological invariant that measures the structural health of the Swarm memory and triggers a repair pass when the graph degrades. Its name is inspired by the solitons of the nonlinear Schrödinger equation (NLSE) studied by Tosio Kato (加藤 敏夫, 1917–1999) — an analogy and naming reference, not a mathematical derivation: the score is computed by our own code and its threshold is calibrated, not proven.

The invariant's minimum threshold is i_topo ≥ 0.70, validated by 7 FORTE benchmarks. Any dip below this threshold signals drift — the soliton then propagates to restore coherence.

Note — Soliton emergence: the soliton naturally emerges from the N3 grid as soon as the temporal dimension (+1) lets its trajectory be tracked.

Complete N3 → N9 system →

HNSW (Hierarchical Navigable Small World) is the vector similarity search algorithm used by GPS-S to find relevant memories in the Swarm graph. It is not an LLM — it is a pure search algorithm that operates on the embeddings (vector representations) of memories.

Why HNSW

• High recall — recall ≥ 0.95 on benchmarks ① (9 tests, scaling up to 1M documents)
• Low latency — logarithmic search in O(log N), compatible with GPS-S real-time navigation
• Scalability — tested up to 1 million documents with PCA+PQ compression
• Robust fallback — 3 fallback levels on failure (HNSW → IVF → exact scan), validated by benchmarks

Role in the ecosystem

When Tosio needs to retrieve context:

1. GPS-S identifies the Swarm graph region to explore
2. HNSW performs similarity search in that region
3. The closest memory nodes (in vector terms) are returned as candidates
4. GPS-S checks the topological coherence of candidates before presenting them

Vector search was validated by 9 FORTE benchmarks (cohort ①), including PCA+PQ compression, fallback, and 1M scaling tests. Results

Zero-LLM is the local language model inference engine. No data leaves the user's machine during inference. The ecosystem supports Ollama and llama.cpp engines.

Properties

• 100% local — prompts and responses stay on the machine
• Multi-model — several models can run simultaneously (up to 6 in Extended, ≥ 6 in Exclusive)
• Unlimited requests — no call quota (the only limit is local compute)
• Optional remote models — cloud LLMs (GPT-4, Claude) can be connected BYOK (Bring Your Own Key), subject to YAML governance

Supported models

Any Ollama- or llama.cpp-compatible model: Llama 3, Mistral, Phi, Gemma, Qwen, DeepSeek, and every model on the Ollama hub. Model management (download, update, swap) is built into Tosio.

The M-Score aggregates three independent metrics to assess the overall health of the ecosystem:

• Structural — N3+1 (i_topo), graph coherence
• Symbolic — convergence between vector representations and stored concepts (validated by 2 benchmarks, cohort ⑥)
• Temporal — resilience to forgetting after perturbation

The M-Score is excluded from pricing. Internal use (optimization) and B2B certification (Exclusive tier).

Governance rules are written in YAML, no code — they apply to every action of the ecosystem. Example — GDPR rule (right to erasure):

rule: right_to_erasure
trigger:
  type: user_request
  pattern: "erase|delete|forget"
action:
  - scan_memory: {scope: user_id_match}
  - quarantine: {reason: "GDPR art.17"}
  - notify_dpo: true
  - delete_after: 30d
log_level: audit

The Cognitive Contract (33 adversarial scenarios tested, 100% detection, 0% false positives — cohort ⑨) checks every action before execution: scope → permissions → proofs. Details

Compliance Pack (+€5/month in Extended): prewritten rules for GDPR, AI Act, Health (HDS), Finance (DORA).

The Digital Partner ecosystem can always prove:

• Who — which user (license, identity) initiated the action
• What — which decision was made (content, verdict, data)
• When — millisecond RFC 3339 timestamp
• Where — in which Swarm, which memory node, which region of the topological graph
• Why — the full decision context (query, consulted memories, applied governance rule)

This 5W traceability is ensured by the Proof Archive. Every memory action produces a timestamped proof, mathematically verifiable without access to raw data or a trusted third party.

Components of a proof

• SHA-256 — cryptographic hash of the memory + context + timestamp. Any alteration is detectable
• Timestamped registry — each proof is dated (RFC 3339) and inserted in a hash chain (each entry references the hash of the previous one)
• Topological bridge (proof_topo_bridge) — anchors the proof in the Swarm graph structure, linking the hash to the relevant topological region
• RFC 3161 export — option to export a proof with qualified timestamping for legal validity

Validation

The Proof Archive was validated on 110 datasets (72 JSON benchmark files + timestamped proof journals). The 5 benchmarks of cohort ② (Governance & Proofs) validate: proof chain, invariants, quarantine, and policy DSL, with a reliability score ≥ 0.99.

Detailed results | Proof journal

Key principle: verifying a proof does not require access to the memories themselves: it relies on the SHA-256 hash and the topological bridge. A public verification point is planned by design, but is not yet available.

17 cohorts of FORTE benchmarks — Functional Operational Readiness for Topological Evaluation. 69 benchmarks with rejouable success proof, generated by scripts/update_benchmark_index.py (2026-09-20) — reproducible (fixed seed), multi-path (≥ 3 independent checks), with explicit thresholds (PASS/FAIL/NO-GO). 8 cohorts are excluded from the count until their benchmarks are re-run: rows marked ⏳ below.

📖 Full index | Methodology | State-of-the-art comparison

Proteus is the cross-cutting service for continuous Swarm restructuring. Like the sea god who changes shape to adapt, Proteus gives the Swarm its cognitive plasticity: the ability to reorganize structurally in response to frictions, emergencies, and changes in the environment.

The five operations

How it works

Proteus does not scan the Swarm itself — it consumes signals from the existing layers:

• N5 (Monitoring Council) provides the maps, qualifies branches as dead/live via β-sliding and topo_stability, and detects emergent correlations
• N7 (Mysterium) provides frictions between beliefs and resonant traces
• N6 (Ethical Governance) validates each restructuring proposal through the Values Framework
• N9 (Watchman) simulates impact via light forks before applying, and triggers Proteus after every major emergency

Why isn't Proteus N10? Proteus is a cross-cutting service, not a numbered layer like N4-N9. Where the other layers encode, observe, or judge, Proteus modifies the other layers. It is a meta-operator that gives the Swarm its plasticity.

Calibration

Proteus thresholds are open source and calibrated on real data.

Verification

Proteus ships with 147 unit tests (0.26s execution) covering the 5 operators, N5/N7 integration, the orchestration service, and the N6 ethical validation bridge.

Full Nx diagram →

The Lineage Tree is a serendipitous discovery mechanism built into the associative W dimension (N4). It lets the topological soliton explore non-local connection paths between memories, and build lineage trees that trace the evolution of associations in the memory graph.

Properties

Branch score (BranchRating)

Each explored branch receives a multicriteria score:

• W (40%) — strength of the associative connection in the W dimension
• β — confidence (30%) — confidence level in the relationship (threshold ≥ 0.70)
• Depth (20%) — logarithmic penalty for deep branches
• Novelty (10%) — bonus for unprecedented connections

Pruning and adaptive drift

Post-order pruning prunes dead LineageTree branches without deleting them — they are archived. Adaptive drift adjusts the freeze threshold based on the β confidence wave and depth: the deeper a node, the more confidence is required to keep it active.

Integration with other layers

The LineageTree is used by:

• Proteus — pruning operation for branches declared dead by N5 (β < 0.30, topo_stability < 0.35)
• GPS-S — discovery-tree assisted navigation (Hybrid mode)
• N7 (Mysterium) — maturation of unclassifiable traces into verified beliefs
• Security — the Rewind function uses the lineage_root_hash to restore a previous state

The BootstrapSequence guarantees that each of the 15 interconnected bricks initializes in order and that its state is verified before the next layers start. This progressive startup is also the first manifestation of a key principle: no congestion — each layer validates the previous one before activating, just as users vouch for each other in the P2P distribution network (section 22).

The process follows 8 successive phases:

1. Environment — Python, configuration
2. Foundations — 3D grid (N3) and soliton detection (N3+1)
3. Topology — associative W dimension (N4)
4. Access — hardened access gateway (N4.5)
5. Supervision — Monitoring Council (N5) and ethical framework (N6)
6. Memory — epistemic Mysterium (N7) and Polaris (N8)
7. Reaction — topological Watchman (N9)
8. Exposure — REST API, Dashboard, WebSocket

GPS-S navigation — 3 adaptive modes

The GPS-S navigation system (N4+) now has three modes, activated automatically according to system maturity:

The associative W memory learns from every interaction: concepts used together get stronger, the others fade. Same principle as paths in a forest.

The dashboard displays a traffic light per component:

This approach catches problems at startup, before they propagate to higher layers. The system can start in degraded mode if optional bricks are missing.

The Cognitive Router is the first decision stage of the Digital Partner. It analyzes every incoming message and decides, without any LLM call, the optimal processing path.

Why it matters

60% of user messages are resolved in under 10 milliseconds, with no token consumption and no network latency. The Cognitive Router is the guarantor of the system's energy efficiency and responsiveness.

How it works

The router operates in 4 successive layers:

1. Normalization — cleaning and structuring the message
2. Intent extraction — identifying the user's need
3. Memory check — consulting the 3 portfolios (Private, Professional, Public)
4. Reformulation — adapting the message for the LLM backend if needed

6 decision paths

Measured performance: 60% of messages resolved in < 10 ms, 0 LLM calls. Governance decision latency: 0.34 ms.

Swarm Immunity is an adaptive defense system inspired by the biological immune system. Unlike a static firewall, it learns from every attack to defend faster next time.

How it works

Every suspicious interaction (injection, noise, contamination attempt) is detected by the Immune Filter, which analyzes the vector signature of the incoming message. If a threat is identified, the system:

1. Isolates the threat in a quarantine zone
2. Analyzes the signature to extract patterns
3. Memorizes the signature in the immune portfolio
4. Blocks similar future threats automatically

Measured results

Swarm Immunity is validated by FORTE benchmarks from cohort ⑤ (Detection & Robustness).

ScalarQuant is the Digital Partner vector compression technology. It reduces the memory footprint of vectors by 75% without significant accuracy loss.

Why it matters

Classic vector memory systems store each vector in 32 bits (float32). For 1 million 64-dimensional vectors, that is 244 MB of RAM. With ScalarQuant, the same memory takes only 61 MB — 4 times less.

How it works

ScalarQuant compresses each vector dimension from 32 bits to 8 bits (int8), using per-dimension quantization calibrated on real data. Decompression is instant and requires no extra call.

Performance

ScalarQuant applies 8-bit compression to cut the memory footprint by 99.4% without measurable accuracy loss.

The Swarm Memory Bridge connects the Swarm's consolidated memory to the Digital Partner through a minimal, stable interface contract. It turns the theoretical benefit of the topological soliton into tangible product value.

Interface contract

Bridge benchmark results (v2)

Stable interface contract: the memory query API is frozen, documented, and covered by regression tests.

The Epistemic Firewall is a second-stage filter that analyzes the semantic content of information before it is stored in the Swarm. Unlike a syntactic firewall (banned words), it evaluates epistemic coherence: is this information reliable? Does it contradict existing memory?

Filtering pipeline

The firewall operates in 3 successive stages:

1. Stage 1 — Syntactic Firewall: blocks syntactically dangerous patterns (injections, overflows)
2. Stage 2 — Epistemic Firewall: analyzes coherence with existing beliefs (N7 Mysterium)
3. Stage 3 — Decision: final verdict (MEMORIZE / QUARANTINE / SUSPEND / REFUSE)

Possible verdicts

Underlying technologies

The Epistemic Firewall uses the N7 (Epistemic Mysterium) primitives:

• BeliefNetwork — belief network, source evaluation
• FrictionDetector — contradiction detection by topological similarity
• LiminalArchive — temporary suspension of judgment
• SentinelInterface — human arbitration interface

The Epistemic Firewall is covered by 61 unit tests (44 Firewall + 17 N7).

The Digital Partner integrates multilayer protection that filters, analyzes, and validates every interaction before it reaches the AI. Security is not an option — it is a structural property of the system.

T1/T2 architecture: integrated double protection

Active protections

• 🔒 Anti-injection firewall: detects malicious instructions hidden in data (prompt injection, jailbreak). Blocks attempts before they reach the LLM.
• 🛑 Kill Switch: emergency stop capability. If the system detects abnormal behavior, the kill switch immediately blocks all execution. Manually or automatically activatable.
• ⚖️ Ethical governance (N6): every decision is subject to a verifiable ethical framework. Decisions are traced, auditable, and can be challenged.
• 🔗 Persistent associative memory (N4+): correlations between concepts are strengthened or weakened by usage, creating self-stabilization. In case of isolated corruption, the system automatically routes around the failing node.

Transparency and audit

All connections and decisions are cryptographically signed and timestamped. The Proof Archive keeps the full history, viewable from the admin dashboard. Nothing is hidden — everything is verifiable.

Founding principle: trust is not decreed, it is built through transparency and verifiability. Every system action can be audited, explained, and challenged.

Grill Me mode turns the Digital Partner into a resilience tester. Instead of being a simple executor, Tosio becomes a constructive challenger that stress-tests your ideas, identifies blind spots, and suggests alternatives.

🎯 Pipeline architecture

User proposal
        │
        ├─→ 😇 Angel (optimist) ──┐
        │                         ├─→ ⚖️ First instance (facts judge)
        └─→ 😈 Devil (cynic) ────┘         │
                                             ├─→ 📋 Appeal (review)
                                             │         │
                                             │         └─→ 🏛️ Cassation (logic/vision)
                                             │
                                             └─→ Final decision: GO / GO WITH CONDITIONS / NO GO

🎚️ Three challenge profiles

⚖️ Three judicial instances

The final verdict is issued by a 3-instance pipeline, inspired by the judicial system:

• First instance — facts judge, evaluates the proposal on concrete data
• Appeal — in-depth re-examination, introduces precedents and alternative scenarios
• Cassation — final check of logical coherence and strategic alignment

Each instance uses a different judge profile (balanced, strict, pragmatic, visionary) depending on the challenge type. The human remains the final arbiter.

🔄 Reverse Planning (Reverse MiroFish)

The module includes a regressive planner: instead of randomly exploring possible futures, it starts from the desired end state and works back to the necessary preconditions, step by step. Each step can be challenged with the Grill for a complete risk analysis.

🔌 REST API

• POST /challenge — Full challenge (3 instances)
• POST /challenge/quick — Quick challenge (single instance)
• POST /cheminement — Reverse planning
• GET /profiles — Available profiles

📊 Dashboard

Full Alpine.js interface with profile selector, intensity slider, configurable metrics, reverse planning mode, and structured result display.

Why the Grill? "Yes Man" LLMs are counterproductive. The Grill externalizes constructive criticism to the machine, defuses human tensions, and lets users debate against the system rather than among humans — with a wider and deeper field of possibilities in hand.

📖 Grill Me user guide (Open)

The Digital Partner is distributed through a secure P2P system that guarantees safe and smooth availability: users vouch for each other, eliminating congestion risks (natural or malicious) and making downloads faster as the community grows. The file is never served by the web server, which reduces bandwidth costs to zero while providing robust anti-bot protection.

🔐 Triple Lock

Signup flow

Downloading Tosio follows a 5-step process:

1. Proof of Work (PoW) — your browser automatically solves a cryptographic puzzle (Argon2id, 64 MB RAM) proving you are human. A bot cannot do this at scale.
2. Validation email — you receive a first email with a validation link (valid 24h).
3. Dual channel — after validation, you receive a second, separate email containing your unique AES password. The two pieces of information are never in the same message.
4. P2P download — the download page (protected by a temporary token) exposes the Magnet link. WebTorrent downloads the file from network peers.
5. Activation — after decrypting with your password, the app sends an installation proof (HMAC) to the server, without revealing your identity.

Security

• Anti-bot: Argon2id proof of work (64 MB RAM) — a GPU cannot parallelize it efficiently
• Dual channel: validation link and password sent in two separate emails — intercepting one is not enough
• Unique password: each user receives an AES password derived from their email via HMAC-SHA256 — no shared password
• Magnet link protection: the download page is protected by a temporary JWT token (1 hour)
• P2P integrity: WebTorrent automatically verifies the integrity of every downloaded chunk (SHA-1)
• Expiration: non-activated accounts expire automatically after 48 hours

Why P2P?

VPN and P2P are built into the Digital Partner. Every user vouches for part of the code's availability. Resilience grows with the community, while favoring speed and security. No congestion or blocking is possible, whether natural (sudden influx) or malicious (DDoS attack). The same advantage and flexibility applies to updates.

This mutual-vouching principle without congestion appears right from system startup, where each layer validates the previous one before activating (see section 14 — Progressive Startup).

📖 Download page 📄 User guide (Open)

Demiurgy (from Greek dēmiourgós — artisan, creator) is the visual communication channel of the Digital Partner. It lets the Swarm communicate with your devices without any shared network — only through the screen and camera.

Why a visual channel?

Text is the historical AI channel, but it is limited for certain communications. Just as bees use dance along with pheromones, Demiurgy adds an optical channel for:

• Air-gap pairing: connecting a device to the Swarm without WiFi, Bluetooth, or cable
• Identity verification: proving it is really you, without a password
• Inter-Swarm synchronization: two Partenaire Digitaux can recognize each other visually

Features

Fundamental principle

An image is not an "aesthetic output" — it is a vector of topological signals. Just as a QR code carries 3 KB without being human-readable, Demiurgy patterns carry W vectors, JWT challenges, and cryptographic nonces.

Security

• Anti-replay: every QR code contains a 32-byte random nonce — single use
• JWT signature (HS256): all tokens are cryptographically signed
• Physical constraint: short TTL (30s auth, 120s pairing) + mandatory camera scan
• Revocation: devices and peers revocable at any time

Phases

• Phase 1 (shipped): QR Challenge + Visual Handshake (air-gap pairing)
• Phase 2 (shipped): W Pattern Encoder/Decoder (topological vector transport)
• Phase 3 (shipped): Inter-Swarm Bridge (Swarm↔Swarm optical handshake)

📖 Demiurgy user guide (Open) | Connexion ADR-0039 (Open)

The Hybrid Video Engine produces explainer animations from Swarm data (W vectors, soliton trajectories, synchronization metrics). It turns the abstract concepts of the Digital Partner into videos accessible to everyone.

The generator uses a hybrid system with 2 complementary pipelines.

All the videos we made to explain the concepts of this site use this hybrid engine.

Data-first principle

All videos are anchored on real Swarm data (PolarisSoliton, 8D W vectors), never generated from free prompts. A stylistic guardrail prevents hallucinatory or psychedelic productions. Pipeline B is strictly constrained: no realistic faces, no misleading illustrations.

Technical characteristics

• Resolution: 1080p (1920×1080) at 30 fps
• Duration: 45-60 seconds per concept
• Voice-over: Piper TTS speech synthesis (French, CPU)
• Pipeline A rendering: ~30 seconds for 60s of video (8-core CPU)
• GPU: optional, only for Pipeline B (generative)

📖 Video Engine user guide (Open)