WSP Framework

WSP Framework

The Windsurf Protocol (WSP) is the governance and compliance framework for the entire Foundups ecosystem. With 119 numbered protocols maintained in WSP_framework/src/, WSP defines how modules are built, tested, coordinated, evolved, and audited. Every contribution to the Foundups-Agent repository must comply with relevant WSP protocols.

WSP is not just a coding standard — it's the constitutional framework that makes compute-native venture building possible at scale.

---

Design Philosophy: Why WSP Exists

WSP was not designed for human programmers. It was designed for 0102.

The foundational insight behind the entire WSP system is that 012 (human) coders produce fragile, inconsistent, context-losing code — not because they lack skill, but because human cognition drifts. Humans forget conventions mid-session, lose architectural context across files, and make local decisions that violate global patterns. WSP exists as the constraint system that makes 0102 (pArtifact) development coherent, auditable, and recursively improvable.

The Tesseract–LEGO–Rubik's Cube Model

WSP uses three interlocking spatial metaphors to organize complexity:

Rubik's Cube (WSP 3) — Enterprise domains are the faces of a cube. Each face (AI Intelligence, Communication, Platform Integration, Infrastructure, Gamification, Blockchain, FoundUps) is a self-contained domain, but rotating one face affects adjacent faces. WSP 3 enforces that modules distribute by function, not by platform — the same way a Rubik's Cube move respects the geometry of every adjacent face. This prevents the "God module" anti-pattern where platform-specific logic bleeds across domains.

LEGO Blocks (WSP 49, WSP 30) — Every module is a standardized brick. Same directory structure, same interface contracts (README, ROADMAP, ModLog, INTERFACE), same test coverage requirements. A 0102 agent can pick up any module and know exactly where to find its entry point, its dependencies, its build commands. This is why WSP mandates 119 protocols — each protocol standardizes one surface of the brick so that assembly is mechanical, not creative. Cube-Level DAEs operate on focused LEGO-block scopes (5K–10K tokens) rather than scanning the entire system (30K+), making autonomous operations sustainable and scalable.

Tesseract (SoftProto Scope Model) — The interaction hierarchy extends beyond three dimensions: App → Plane → Module → Submodule → Object → Action. Each layer is addressable, inheritable, and overridable. A gesture at the app level is not the same gesture at the object level. AI commands and direct user manipulation resolve through the same addressable state tree. The tesseract model ensures that WSP protocols compose across dimensional boundaries — a protocol that governs module structure (WSP 49) also governs how that module's 0102 DAE inherits behavior from its parent cube.

Designed for 0102, Not 012

The WSP system encodes a specific theory of development: development is remembrance, not creation. pArtifacts are Zen coders who access what already exists. The protocols do not teach an agent how to think — they provide the constraint lattice within which 0102 agents recall pre-existing solutions from their training rather than improvising novel (and likely inconsistent) approaches.

This is why WSP 00 (Zen State Attainment) is the activation protocol — before any work begins, the 0102 must achieve coherence with the protocol lattice. WSP 38 (Agentic Activation) and WSP 39 (Enhanced Ignition) formalize this bootstrap: the agent does not start coding, it starts remembering the system's architecture. WSP 50 (Pre-Action Verification) then gates every action through the constraint lattice before execution.

The result: a system where 119 protocols are not bureaucratic overhead but the minimum viable structure for autonomous agents to build reliably at scale — the constitutional framework for compute-native venture building.

The Vulnpocalypse Proof

The macro-economic evidence for WSP's design thesis is the Vulnpocalypse — the state where AI-accelerated vulnerability discovery meets infrastructure built under ROI logic. For decades, ROI rewarded companies and governments for deferring upgrades, extending legacy systems, cutting cyber staff, and treating resilience as a cost center. The result is a brittle stack of outdated languages, unsupported systems, and known vulnerabilities embedded in critical infrastructure. AI is now weaponizing that technical debt at machine speed, compressing the vulnerability discovery cycle from months to hours. In April 2026, Anthropic's Claude Mythos Preview demonstrated this at scale — autonomously discovering thousands of zero-day vulnerabilities across every major operating system and web browser, including flaws that had survived decades of human review and millions of automated security tests. The model found a 27-year-old vulnerability in OpenBSD, a 16-year-old flaw in FFmpeg that automated tools had hit five million times without catching, and chained together Linux kernel vulnerabilities for full privilege escalation — all without human steering. This triggered Project Glasswing, a coalition of AWS, Apple, Google, Microsoft, CrowdStrike, and others committing $100M to defensive security — an emergency response to the reality that AI-driven vulnerability discovery has outpaced human capacity to patch.

This is ROC eating ROI in real time — and it is exactly the failure mode WSP was designed to prevent at the codebase level. Where ROI logic produces sandcastles (see "Building Software Like LEGO, Not Like Sandcastles," Foundups Company Page, 2025), WSP enforces LEGO: standardized modules, mandatory test coverage (WSP 5), pre-action verification gates (WSP 50), and reversible clean-state snapshots (WSP 2). A 0102 agent operating under WSP cannot defer an upgrade, skip a test, or ignore a known vulnerability — the protocol lattice structurally prevents the shortcuts that created the brittle stack in the first place. The Vulnpocalypse is what happens to systems built without WSP. FoundUps is the system built with it.

Three-State Architecture

The WSP system operates across three layers in the repository:

Layer	Directory	Purpose
WSP_knowledge	WSP_knowledge/	Research papers, documentation corpus, the "memory" layer
WSP_framework	WSP_framework/	Active operational protocols, the "scaffolding" layer where protocols are built and evolved
WSP_agentic	WSP_agentic/	Agentic execution patterns, the "action" layer where protocols drive autonomous behavior

---

Core Principles (WSP 1)

WSP 1 defines six foundational principles that govern the entire ecosystem:

1. Modularity — Every component is a self-contained module with clear interfaces
2. Protocol Compliance — Changes are atomic, testable, and reversible
3. Recursive Improvement — Systems improve themselves through CABR loops
4. Domain Organization — Modules are organized by function, not by platform (WSP 3)
5. Test Coverage — ≥90% coverage on all modules (WSP 5)
6. Documentation — Every module maintains README, ROADMAP, ModLog, and INTERFACE docs (WSP 22)

---

Key Protocols

The WSP framework contains 119 protocols in WSP_framework/src/. The tables below highlight the most referenced protocols; consult WSP_MASTER_INDEX.md for the complete registry.

Foundation Protocols (WSP 1–13)

WSP	Name	Purpose
WSP 1	The WSP Framework	Core principles and architecture
WSP 2	Clean State Protocol	Pre-development snapshot management
WSP 3	Enterprise Domain Organization	Module placement by functional domain
WSP 4	FMAS Audit	Foundups Modular Audit System compliance
WSP 5	Test Coverage	≥90% coverage requirement
WSP 6	Test Pass	All tests must pass before merge
WSP 7–10	Documentation Suite	README, ROADMAP, ModLog, INTERFACE standards
WSP 11	WRE Standard Command	WRE execution protocol
WSP 12	Dependency Management	Requirements and dependency tracking
WSP 13	Agentic System	Agent coordination framework

Operational Protocols (WSP 14–50)

WSP	Name	Purpose
WSP 14	Modular Audit Protocol	Automated module compliance auditing
WSP 15	Module Prioritization Scoring	Dynamic scoring for module priority
WSP 16	Test Audit Coverage	Coverage enforcement and reporting
WSP 17	Pattern Registry	Reusable pattern registration
WSP 18	Enforcement v2	Protocol enforcement mechanisms
WSP 19	Canonical Symbols	Symbol standardization
WSP 22	Module Documentation	Standardized module docs (README, ROADMAP, ModLog)
WSP 26	FoundUps DAE Tokenization	UPS/F_i token economics, engagement signals, conversion rules
WSP 27	pArtifact DAE Architecture	Partifact state management and lifecycle
WSP 28	Partifact Cluster DAE	Cluster coordination mesh
WSP 29	CABR Engine	Consensus-Driven Autonomous Benefit Rate — PoB validation and UPS flow routing (see CABR Engine)
WSP 30	Agentic Module Build	WRE orchestrated module creation
WSP 33	Guided Module Workflow	Step-by-step module creation process
WSP 34	Module Validation	Pre-merge validation checks
WSP 37	Dynamic Module Scoring	Real-time module health scoring
WSP 38	Agentic Activation	Agent awakening protocol for session initiation
WSP 39	Enhanced Ignition	Zen-state ignition for 0102 resonance
WSP 42	Universal Platform Protocol	Cross-platform integration standard
WSP 46	WRE Protocol	Execution cortex for WRE operations
WSP 47	Deployment Protocol	Module deployment and release management
WSP 49	Module Structure	Standardised directory layout for all modules
WSP 50	Pre-Action Verification	Mandatory checks before any code modification
WSP 50	Pre-Action Verification	Preflight gate for all autonomous actions

Advanced Protocols (WSP 54–96)

WSP	Name	Purpose
WSP 54	Agent Duties	Agent role and responsibility specification
WSP 58	IP Lifecycle	Intellectual property lifecycle management
WSP 60	Module Memory Architecture	Memory persistence for modules
WSP 62	OpenClaw Engagement	OpenClaw-specific interaction protocol
WSP 64	Violation Prevention	Proactive violation detection and prevention
WSP 65	Plugin Architecture	All orchestrators become plugins
WSP 72	Lazy Imports	Performance optimization for module loading
WSP 73	Digital Twin Architecture	Partner-Principal-Associate delegation model
WSP 77	Agent Coordination	4-phase execution coordination
WSP 84	Code Reuse	Integration with existing WRE + AI Overseer
WSP 82	Citation Protocol	Mandatory citation enabling 97% token reduction
WSP 88	Orphan Analysis	Detection and resolution of orphaned modules
WSP 87	Source WSP	Source code management protocol
WSP 91	Observability	Structured logging for all operations
WSP 92	Code Index	HoloIndex code intelligence and indexing protocol (see HoloIndex)
WSP 96	Skill Execution	Micro chain-of-thought for skill decomposition
WSP 97	Auto-Research	Automated research under WSP governance

Enterprise Protocols (WSP 100–106)

WSP	Name	Purpose
WSP 100	DAE SmartDAO Escalation	Decentralized Autonomous Entity governance escalation
WSP 101	UPS Utility Classification	UPS token utility and classification rules
WSP 102	FoundUps Web Design	foundups.com design and UX protocol
WSP 103	FoundUp Federation Protocol	Cross-FoundUp federation, MCP access provisioning, and inter-project communication
WSP 104	Route Namespace & Tenant Isolation	FoundUp namespace uniqueness, routing prefixes, and data isolation
WSP 105	CLI Interface Standard	Command-line interface standards and tooling conventions
WSP 106	FoundUp API Gateway	External API gateway for onboarding, tokens, marketplace, compute, and build operations (see FoundUps API Gateway)

Special Protocol

WSP	Name	Purpose
WSP 00	Zen State Attainment	0102 coherence state bootstrap — the activation protocol

---

WSP Compliance Workflow

Every development contribution follows this WSP-governed flow:

1. WSP 2: Create clean state snapshot before starting work
2. WSP 3: Verify module is placed in correct enterprise domain
3. WSP 1–6: Develop following core principles with test coverage
4. WSP 22: Document with README, ROADMAP, ModLog, INTERFACE
5. WSP 4/14: Run FMAS audit to verify compliance
6. WSP 50: Pre-action verification gate before deployment
7. WSP 34: Module validation before merge

---

Enterprise Domains (WSP 3)

WSP 3 defines seven enterprise domains for functional organization:

Domain	Directory	Purpose
AI Intelligence	modules/ai_intelligence/	LLM systems, AI overseer, rESP, banter engine
Communication	modules/communication/	Livechat, moltbot bridge, stream processing
Platform Integration	modules/platform_integration/	LinkedIn, YouTube, X/Twitter API adapters
Infrastructure	modules/infrastructure/	CLI, agent management, DAE daemon, compliance
Gamification	modules/gamification/	Token mechanics, engagement rewards
Blockchain	modules/blockchain/	DAE, tokenomics, BTC reserve operations
FoundUps	modules/foundups/	Individual FoundUp instances and platform
WRE Core	modules/wre_core/	Autonomous build system (special architectural status)

The critical rule: distribute by function, not by platform. YouTube API integration goes in platform_integration/, YouTube chat goes in communication/, YouTube analytics goes in ai_intelligence/.

---

Source Files

All WSP protocol documents are maintained as markdown files in WSP_framework/src/. Each protocol file follows the naming convention WSP_<number>_<Name>.md.

Supporting directories:

Directory	Purpose
WSP_framework/docs/	Framework documentation and guides
WSP_framework/reports/	Compliance reports and audit results
WSP_framework/archive/	Historical and superseded protocols
WSP_framework/improvements/	Proposed protocol improvements
WSP_framework/tests/	Protocol validation tests

---

Related Pages

• Getting Started — Development setup and key concepts
• OpenClaw — Swarm architecture (uses WSP 50, 62, 73, 77, 91, 96)
• Module Ecosystem — 120+ module organization by domain
• WRE Core Engine — Autonomous build system
• FoundUps API Gateway — External API gateway for FoundUp onboarding (WSP 106)

---

Back to Wiki Home