WeftOS: The Vision

How an automation agency became a cognitive operating system, and why that matters for everyone building with AI.

The Arc

This project did not begin as WeftOS. It did not begin as a kernel, or a causal graph, or a mesh network. It began as a business plan for an automation agency called WeaveLogic AI.

Phase 1: The Agency (2024)

WeaveLogic AI was conceived as an "AI-native development and automation agency" -- a consultancy that would build N8N workflow automations and custom AI solutions for SMEs. The core insight was sound: the market was bifurcated between "Floor-Raisers" (agencies using AI for internal efficiency) and "Ceiling-Raisers" (firms that build AI into the product itself). WeaveLogic aimed to be the latter.

But building custom AI solutions for clients revealed a deeper problem than workflow automation could solve.

Phase 2: Weave-NN -- The Knowledge Graph (2024-2025)

The first product to emerge was Weave-NN: "an AI-powered knowledge graph for managing AI-generated documentation." The problem it addressed was real and personal -- the team was drowning in AI-generated markdown.

Weave-NN evolved through 14 phases over roughly a year, from an Obsidian vault with a Python MCP backend to a full knowledge graph with an Autonomous Learning Loop (Perceive, Reason, Execute, Reflect, Learn). The key architectural idea that emerged was the Neural Network Junction -- the Weaver service as a synapse where multiple AI systems connect and share knowledge through a common graph substrate.

What worked: the knowledge graph as shared memory, the learning loop, the compound learning effect, and the vault primitives. What did not: TypeScript + Python + RabbitMQ + N8N + Obsidian was too many moving parts, there was no actual causal reasoning, no cryptographic provenance, no governance, and the knowledge graph could be tampered with silently.

Phase 3: The CMVG Insight (2026-03-19)

While designing a WASM test rig for on-device vector search, a test data generator produced something unexpected: 384-dimensional embeddings organized as nodes in a Bidirectional Temporal Merkle DAG with typed causal edges. The recognition that followed became the CMVG concept note -- "Causal Merkle Vector Graphs as a General-Purpose Cognitive Primitive."

Three layers that are individually well-understood become qualitatively different when combined:

SEMANTIC (HNSW vectors) -- "What is similar?"
    O(log n) approximate nearest neighbor search

CAUSAL (DAG edges) -- "What caused what?"
    Typed, weighted, directed edges
    Laplacian spectral analysis, community detection

PROVENANCE (Merkle chain) -- "Can I prove this happened?"
    BLAKE3 hash chains, Ed25519 signatures, HLC ordering
    Tamper-evident, offline-verifiable, append-only

The computational profile: incremental operations total 3-10ms per tick on a 1000-node graph with 384-dim vectors. Lightweight enough for an ARM Cortex-A53 with 2GB RAM.

Phase 4: clawft + WeftOS (2026-02-28 to present)

The implementation began as a Rust rewrite: what if the knowledge graph, the learning loop, the governance model, and the mesh network were all built on the same CMVG primitive?

The development followed a rigorous Generate-Analyze-Act cycle: SPARC plans specified each kernel phase, implementation sprints produced the Rust code, symposiums evaluated what was built, and new SPARC plans incorporated symposium decisions. This cycle executed at least 5 complete rotations over 27 days, producing 112 commits, 173,923 lines of Rust across 22 crates, 3,953 tests, and 65 symposium decisions.

Phase 5: The Weaver Analyzes Itself (2026-03-26)

The Weaver performed its first real codebase analysis -- on the clawft repository itself. It ingested 29,029 session log nodes, 112 git history nodes, 215 module dependency nodes, and 92 decision nodes. The analysis identified 12 primary conversations happening in the codebase, 7 meta-conversations, and 5 structural patterns.

This was the moment the system demonstrated what it was: software that understands its own development history, can identify gaps in its own knowledge, and can suggest how to improve itself.

The Problem We Solve

The real problem is not "AI hallucinations" or "context windows." Those are symptoms. The root problem:

Software systems have no memory, no accountability, and no ability to learn from their own history.

For Developers

Codebases are dead artifacts. They cannot tell you why a design decision was made, who made it, what alternatives were considered, or what evidence supported it. Technical debt is invisible until it explodes. Testing is disconnected from risk -- measuring code coverage rather than causal coverage.

For Organizations

AI agents operate without governance. There are no constitutional limits on what an agent can do, no separation of powers, no audit trail. Knowledge leaves when people leave. Compliance requires manual audit trails.

For the AI Industry

LLMs are stateless. RAG is a band-aid: similarity matching is not understanding. Multi-agent systems have no shared consciousness. Deployed AI has no accountability -- when an agent makes a decision that affects production, there is no cryptographic proof of what evidence was available or what reasoning was applied.

What WeftOS Actually Is

Not a chatbot framework. Not a vector database. Not a blockchain.

WeftOS is a cognitive operating system -- it gives any software project:

1. A brain -- ECC causal graph + HNSW semantic memory. Not just "what is similar" but "what caused what" and "what does this predict." The same engine operates in three modes: Act (real-time conversation), Analyze (post-hoc corpus understanding), and Generate (goal-directed planning).

2. A conscience -- Three-branch constitutional governance modeled on separation of powers. Legislative (what agents can do), Executive (runtime approval), Judicial (post-hoc audit). Every privileged operation evaluated against a 5-dimensional effect vector: risk, fairness, privacy, novelty, security.

3. A memory -- ExoChain append-only hash chain with SHAKE-256 hash linking, Ed25519 + ML-DSA-65 dual signatures, witness receipts, and lineage records. Every kernel action that matters becomes a tamper-evident, offline-verifiable, cryptographically-signed chain event.

4. A nervous system -- Encrypted peer-to-peer mesh networking across heterogeneous devices. Noise Protocol handshakes. Hybrid ML-KEM-768 + X25519 key exchange for post-quantum protection. Static seed peers, mDNS LAN discovery, Kademlia DHT for WAN. SWIM heartbeats.

5. A growth instinct -- The Weaver. A cognitive modeler that uses all ECC structures to analyze, understand, and improve. It identifies conversations happening in a codebase, maps causal relationships between decisions and implementations, computes confidence scores, detects anomalies, and suggests what to work on next.

The Three-Layer Architecture

SEMANTIC (HNSW vectors)
  "What is similar to this?"
  Sub-millisecond approximate nearest neighbor search.
  O(log n) with 384-dim or 768-dim embeddings.

CAUSAL (DAG edges)
  "What caused what?"
  8 typed edge kinds: Causes, Enables, Inhibits, Contradicts,
  Follows, Correlates, TriggeredBy, EvidenceFor.
  Laplacian spectral analysis reveals structural health.
  Community detection discovers natural conversation boundaries.

PROVENANCE (Merkle chain)
  "Can I prove this happened?"
  BLAKE3 hash chains with Ed25519 + ML-DSA-65 dual signatures.
  Witness receipts for cross-node verification.
  Offline-verifiable. Tamper-evident. Append-only.

No single layer is novel. The combination -- running on a $35 Raspberry Pi with incremental operations completing in 3-10ms per cognitive tick -- is the contribution.

Where It Applies

Software Development (proven)

The clawft repository itself is the first project analyzed by the Weaver: 29,029 session log nodes ingested, 12 primary conversations identified, 59 architectural decisions tracked, and a critical anomaly detected in the kernel's primary execution loop. Every architectural decision is traceable to the symposium that produced it and the implementation that realized it.

Regulated Industries

The three-layer architecture maps directly to regulatory requirements: clinical decision trails (healthcare), AML decision provenance (finance), air-gapped mesh clusters (government/defense), and regulatory compliance tracking (legal).

IoT and Edge Computing

Designed for constrained devices from the beginning. Runs on ARM64 (Raspberry Pi 4/5, Jetson, Mentra glasses). mDNS auto-discovery on LAN, mesh networking across heterogeneous devices, boot-time calibration benchmarks.

Enterprise AI Governance

Constitutional governance with three branches and separation of powers. Effect vectors scored on 5 dimensions. Environment scoping (dev is lenient, prod is strict). Capability-based RBAC per agent. Chain-witnessed decisions synchronized across all mesh nodes.

How to Deploy

For a Developer (30 seconds)

cargo install clawft-cli
cd my-project
weft agent
weft agent -m "Summarize this project"

For a Team (5 minutes)

weave boot --mesh
weave cluster peers
weave ecc status
weave chain status

For an Organization (1 hour)

Docker Compose with seed nodes, governance configuration, embedding model, chain persistence, and monitoring. The weftapp.toml manifest format packages agent deployments with capability wiring.

For Air-Gapped / Classified (1 day)

Isolated cluster with no external network access. Local Ollama inference. Post-quantum encryption on all internal mesh links. ExoChain provides cryptographic audit trail for compliance.

The Loop

The fundamental insight: development IS a conversation. The conversation IS the intelligence.

GENERATE (agents produce plans using the causal graph)
    |
    | ExoChain links generation to analysis
    v
ANALYZE (Weaver evaluates confidence, finds gaps, scores coherence)
    |
    | ExoChain links analysis to execution
    v
ACT (developers and agents implement changes in real-time)
    |
    | ExoChain links execution back to generation
    v
GENERATE (improved plans based on richer graph and new evidence)
    |
    ...continuous loop

Each transition is a causal edge in the CMVG. When execution reveals that a plan was wrong, the causal graph shows exactly which generation-time decision led to the problem and what evidence was available at the time.

What Is Proven vs. Aspirational

Proven

• The Rust kernel compiles and passes 3,953 tests across all feature combinations
• The ECC causal graph ingests real data (29,029 session log nodes)
• The Weaver identifies structural patterns and detects anomalies in its own codebase
• The mesh networking layer has types, traits, and logic with 224 tests
• The ExoChain produces tamper-evident hash chains with dual signing
• The governance engine evaluates effect vectors through three branches
• 7 platform targets compile (Linux, macOS, Windows, browser WASM, WASI, ARM64, Docker)

In Progress

• ONNX embedding backend (semantic search currently uses mock embeddings)
• Mesh networking Phase 2 (wire I/O: actual TCP/WebSocket connections)
• Cross-project Weaver analysis
• Public Fumadocs documentation site

Aspirational

• External project adoption
• crates.io publication
• Real-world regulated industry deployment
• Federated mesh clusters across organizations
• Multi-language support via MCP bridge

Differentiation

From Agency to OS

The WeaveLogic business plan asked: "How do we help businesses automate their processes with AI?"

The Weave-NN knowledge graph asked: "How do we manage the knowledge that AI produces?"

The CMVG insight asked: "What if the knowledge structure itself could reason about causation and prove its own integrity?"

WeftOS answered: "Build the operating system."

The arc was not planned. An automation agency needed a knowledge graph. The knowledge graph needed causal reasoning. Causal reasoning needed cryptographic provenance. Provenance needed a kernel. The kernel needed governance. Governance needed a mesh. The mesh needed a cognitive substrate. The substrate needed a Weaver. The Weaver analyzed the system that built it and found 12 conversations, 65 decisions, and a confidence score of 0.78.

The next conversation will raise that score.