Contract-Driven WASM Runtime
Traverse is a contract-driven Rust and WASM runtime for discovering, validating, and composing portable business capabilities across browser, edge, cloud, and AI pipeline — without rewriting logic for each environment.
The problem
Most distributed systems have a logic problem nobody talks about. The same business rule — a pricing formula, an eligibility check, a validation step — gets implemented separately for the browser, the backend, the edge, and now the AI pipeline.
Nobody planned it that way. It happened because the architecture made assumptions about the environment before it made decisions about the behavior. Over time the copies drift. The system becomes harder to reason about, harder to change, and harder to trust.
Traverse addresses this at the runtime level. Each business capability is packaged as a self-describing WASM module governed by a contract. The same capability runs identically across every target environment.
Core principles
Contracts first
Every capability declares its preconditions, postconditions, invariants, and exception flows in machine-readable form. The runtime enforces them. Nothing executes without a verified contract.
Portable by design
Business logic is defined once, compiled to WASM, and placed where it makes sense. Browser, edge, cloud, or AI pipeline — the capability behaves identically. The environment adapts, not the logic.
Discoverable
Traverse maintains a registry of declared capabilities. AI agents and orchestrators discover what the system can do without reading implementation code. Composition follows contracts, not guesswork.
Explainable
Proposals, validations, approvals, and trace artifacts stay visible and queryable. The runtime does not hide how it reached a decision. Every execution leaves an auditable trail.
Governed composition
When multiple agents work against the same capability graph, contracts prevent conflicts before they happen. The orchestration layer validates composition before execution, not after.
Spec-first
Traverse is built spec-first. Every component has an approved, versioned specification before implementation begins. The spec is the source of truth. The code is the proof.
# traverse.spec.toml — capability contract [capability] id = "pricing.eligibility-check" version = "1.2.0" runtime = "wasm32-wasi" [contract] preconditions = ["customer.tier in ['standard', 'enterprise']", "cart.total > 0"] postconditions = ["result.eligible is bool", "result.reason is string"] invariants = ["enterprise customers never receive standard pricing"] exceptions = ["CustomerNotFound", "CartExpired"] [placement] targets = ["browser", "edge", "cloud", "ai-pipeline"] prefer = "edge" fallback = "cloud"
Lineage and context
Traverse is the runtime expression of ideas that began with Client-Side Microservices Architecture in 2023, expanded into Universal Microservices Architecture, and crystallized into Contract-Driven AI Development.
Each framework addressed a specific problem. CSMA asked why the browser could not be a first-class execution environment. UMA asked why business logic had to be rewritten for every runtime. C-DAD asked why AI agents could not navigate codebases that had no contracts. Traverse is the runtime where those answers become executable.
Pre-implementation. Spec-governed. Personal research and development by Enrico Piovesan.
Traverse is spec-governed and open source under Apache 2.0. Every component is backed by an approved, versioned specification before implementation begins. The runtime, CLI, MCP server, and contract system are all shipping.
The project lives at github.com/traverse-framework/Traverse.