| Internet-Draft | Intent-Driven WebAssembly Framework | November 2026 |
| Cheng, et al. | Expires 20 May 2027 | [Page] |
This document describes an architecture for executing WebAssembly (WASM) modules for network management on heterogeneous edge devices. It describes dynamic bytecode dispatching, the Universal Bytecode Interface (UBI) for abstracting heterogeneous network element capabilities, and metadata models for capability exposure, bytecode deployment, execution context, intent-driven discovery, and security audits. The framework decouples management scripts from platform-specific interfaces. It reuses existing mechanisms for software update, payload manifests, integrity protection, and transport where applicable.¶
This note is to be removed before publishing as an RFC.¶
The latest revision of this draft can be found at https://billwuqin.github.io/webassembly-for-the-edge/draft-chen-opsawg-intent-webassembly-framework.html. Status information for this document may be found at https://datatracker.ietf.org/doc/draft-chen-opsawg-intent-webassembly-framework/.¶
Discussion of this document takes place on the Operations and Management Area Working Group Working Group mailing list (mailto:opsawg@ietf.org), which is archived at https://mailarchive.ietf.org/arch/browse/opsawg/. Subscribe at https://www.ietf.org/mailman/listinfo/opsawg/.¶
Source for this draft and an issue tracker can be found at https://github.com/billwuqin/webassembly-for-the-edge.¶
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.¶
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.¶
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."¶
This Internet-Draft will expire on 20 May 2027.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License.¶
As automated network management evolves, network operators increasingly rely on dynamic, closed-loop control mechanisms. Structured tool interfaces can expose network node capabilities for automated orchestration. Large language models can generate execution logic for management tasks. However, executing dynamic operational scripts or telemetry-collection logic directly on heterogeneous and constrained network devices poses security risks and resource challenges. Container-based execution may introduce startup and memory overhead that is unsuitable for some constrained nodes. WebAssembly [WASM] provides an alternative for lightweight management tasks, subject to the capabilities and limits of the host runtime.¶
WebAssembly-based sandboxing, Universal Bytecode Interfaces, and automated orchestration support the following network management use cases: a) Telemetry Collection: Distributing lightweight bytecode to edge nodes to collect and process local telemetry, returning the results needed for network management. b) Policy Adjustment: Running short-lived tasks on edge nodes or compute boards for traffic inspection and service protection. Each sandbox executes a task with its own permissions and resource limits. Concurrent tasks support different user or service policies, subject to the node’s available capacity. Packet inspection uses authorized host capabilities. c) Device Management: Executing device management operations through authorized host functions. Tasks can access and process local resources without uploading all raw data, supporting deployments with data-transfer or privacy constraints.¶
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.¶
WASM Sandbox: A lightweight, isolated virtual machine environment running inside a host process, executing WebAssembly bytecode with linear memory isolation.¶
UBI (Universal Bytecode Interface): An abstraction layer that exposes host functions to WASM modules. UBI interfaces describe available device capabilities and hide hardware-specific implementations.¶
Node Profile: A structured metadata model used by the framework to advertise a network element's supported UBI interfaces, execution capabilities, runtime information, and required host function privileges. Capability advertisement does not itself authorize task execution.¶
UBI-DP (Universal Bytecode Distribution Protocol): The encapsulation and messaging mechanism used to dispatch compiled WASM bytecode binaries along with metadata across network management channels.¶
WIT (WebAssembly Interface Types): The interface definition language used by the WebAssembly Component Model to define types and functions crossing component boundaries.¶
The proposed framework consists of three logical planes. They separate task orchestration, policy coordination, and execution on edge devices:¶
+--------------------------------------------------------+
| Intent & Orchestration Plane (Management) |
| [Intent Parsing] -> [Workflow Compile] -> [Cap. Match] |
+--------------------------------------------------------+
|
v (Task and constraints)
+--------------------------------------------------------+
| Coordination & Policy Plane (Control Layer) |
| [Static Audit Matrix] -> [CaaS Pool] -> [Hash and Sign]|
+--------------------------------------------------------+
|
v(UBI-DP Dispatching)
+----------------------------------------------------------------------+
| Embodied Execution Plane (Device Layer) |
| [WASM Sandbox] -> [UBI Host Functions] -> [Platform Implementations] |
+----------------------------------------------------------------------+
Intent & Orchestration Plane: Translates network operator intents into structured workflow models and maps required management tools. It identifies target nodes using Node Profiles and passes task constraints to the Coordination & Policy Plane.¶
Coordination & Policy Plane: Acts as the central management controller. It audits requested tasks against security policies, compiles modules via Compilation-as-a-Service (CaaS), and generates cryptographically signed bytecode distribution packages. The signed metadata binds the module digest to its approved host functions and resource limits.¶
Embodied Execution Plane: The physical edge node running embedded WASM runtimes. It validates the module and its associated policy, enforces resource limits, and restricts device access through authorized UBI host functions. A warm process pool retains initialized runtime processes to reduce sandbox setup time; task state and permissions are reset before reuse. Host functions expose the sandbox host’s basic operations, such as reading a counter or updating a permitted policy. The UBI defines the interface visible to the module; platform-specific implementations access local APIs, drivers, or management services. Each invocation is checked against the task’s permissions.¶
The discovery mechanism maps task requirements to available node capabilities:¶
Capability Advertisement: An edge node registers or updates its Node Profile using an existing management channel, such as CoAP [RFC7252] or HTTP/3 [RFC9114]. The profile describes platform information, supported UBI interfaces, and available execution capabilities.¶
Semantic Feature Graph: The controller maintains a capability catalog, optionally represented as a graph, including supported operations and resource budgets.¶
Intent-Driven Matching Filter: The controller selects nodes supporting the required UBI primitives and resource limits.¶
Bytecode distribution MUST be atomic, secure, and self-contained. The network controller utilizes the UBI-DP format to encapsulate the binary and its metadata payload through the following lifecycle:¶
Step 1: Discovery. Edge Node registers its profile, declaring local UBI primitives. Step 2: Audit. Controller matches permissions via the Static Symbol Audit Matrix. Step 3: Transport. Controller compiles code, computes SHA-256 fingerprints, signs payloads, and transmits via HTTP Semantics [RFC9110] or CoAP [RFC7252]. Step 4: Execution. Edge Node validates signatures, provisions execution threads, isolates environments, and executes the authorized module.¶
WASM bytecode dispatched via UBI-DP MUST conform to strict structural and behavioral boundaries:¶
a) Single-Threaded Non-Blocking Loop: To prevent thread starvation on low-power nodes, bytecode SHALL NOT spawn guest-level OS threads. b) Virtual Memory Page Restriction: Memory configuration uses fixed WebAssembly Memory Pages (1 page = 64 KB), statically locked at compilation. c) AOT Compliant Structure: Modules MUST allow instantaneous translation into native machine instructions via AOT engines, bypassing JIT overhead.¶
interface telemetry {
record metric-data {
metric-name: string,
timestamp: u64,
payload: list<u8>
}
read-metric: func(name: string) -> result<metric-data, string>
}
¶
interface actuation {
enum pin-value { low, high }
gpio-write: func(pin: u32, value: pin-value) -> result<_, string>
i2c-transfer: func(
bus-id: u32,
addr: u32,
tx-data: list<u8>,
rx-len: u32
) -> result<list<u8>, string>
}
¶
interface media {
enum resolution-mode {
res-640x480,
res-1280x720,
res-1920x1080
}
audio-start: func(mode: u32, sample-rate: u32) -> result<_, string>
camera-capture: func(res: resolution-mode) -> result<list<u8>, string>
}
¶
The framework uses three types of manifests for different lifecycle stages:¶
Platform Manifest: describes device capabilities and execution environment.¶
Data Collection Manifest: describes data subscriptions and runtime collection context.¶
SUIT Manifest: describes secure software delivery and execution parameters for WASM components.¶
These manifests address different lifecycle stages and avoid duplicating information.¶
The Platform Manifest describes the capabilities and execution environment of an edge node.¶
It can reuse the platform information model defined in draft-ietf-opsawg-collected-data-manifest.¶
The WASM/UBI extension may include:¶
WASM runtime information;¶
supported UBI interfaces;¶
available host functions;¶
security capabilities.¶
{
"ubi-wasm-extension:server-metadata": {
"runtime-version": "wasm-runtime-v1",
"supported-ubi-interfaces": [
"telemetry.read-metric",
"actuation.gpio-write"
]
},
"ubi-wasm-extension:governance-and-security": {
"authentication-supported": [
"mTLS_v1.3"
],
"capability-tokens-defined": [
"telemetry_read",
"net_outbound"
]
}
}
¶
The Data Collection Manifest describes data collection subscriptions and runtime collection context.¶
It reuses the data collection model defined in draft-ietf-opsawg-collected-data-manifest.¶
The manifest may reference external resource policies using policy identifiers.¶
{
"data-collection": {
"platform-id": "edge-node-hetero-01",
"subscription-id": 1001,
"current-period": 300,
"policy-id": "tier_heavy_compute",
"runtime-status": {
"cpu-percent": 87.5,
"action-triggered": "forced-downsampling"
}
}
}
¶
To securely deliver WebAssembly (WASM) bytecode components to constrained edge nodes, the distribution framework adopts the Software Updates for Internet of Things (SUIT) manifest architecture. The management controller encapsulates the compiled WASM binary and its execution policy within a CBOR-based SUIT Manifest, protected via CBOR Object Signing and Encryption (COSE) [RFC9052].¶
The SUIT manifest enforces the strict sequential workflow required for trusted edge execution:¶
Manifest Authentication: The recipient edge node validates the COSE signature of the SUIT manifest using pre-configured trust anchors.¶
Applicability Verification: The device checks whether the manifest's target hardware identifiers, vendor IDs, and class IDs match its local hardware profile.¶
Dependency Resolution: The node verifies and resolves any required UBI interface dependencies declared in the manifest.¶
Payload Fetching: The standalone core .wasm binary payload is retrieved via secure transport (e.g., CoAP block-wise transfer [RFC7252]).¶
Installation & Sandbox Initialization: The verified WASM module is loaded into the isolated runtime environment with static memory page constraints and authorized UBI host symbols.¶
The following example illustrates possible WASM-specific execution parameters associated with a SUIT Manifest. Existing SUIT mechanisms, including manifest authentication, component identification, applicability conditions, and payload retrieval, follow the SUIT specification.¶
The runtime-parameters field represents a framework-specific extension for constraining WASM execution. The definition of these parameters in a SUIT Manifest requires corresponding SUIT extension definitions.¶
{
"suit-manifest-version": 1,
"suit-sequence-number": 42,
"suit-common": {
"suit-components": [
"wasm-telemetry-module"
]
},
"suit-install": [
{
"suit-condition-vendor-id": "example-vendor-id",
"suit-condition-class-id": "example-edge-class-id"
},
{
"suit-directive-fetch": {
"uri": "coap://management-server.local/wasm/module.wasm",
"digest": {
"algorithm": "SHA-256",
"value": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
}
}
}
],
"suit-execute": [
{
"runtime-parameters": {
"allowed-memory-pages-max": 256,
"execution-timeout-ms": 10000,
"allowed-host-functions": [
"telemetry.read-metric",
"actuation.gpio-write"
]
}
}
]
}
¶
Resource constraints are modeled separately from manifests.¶
Platform Manifest describes available capabilities. Data Collection Manifest references runtime policies. SUIT Manifest describes execution constraints.¶
The resource policy defines: - concurrency limits; - rate limits; - sandbox quotas; - resource isolation rules.¶
Manifests reference the policy using policy identifiers.¶
This section details the security mechanisms, static analysis controls, and boundary enforcement strategies required to ensure safe bytecode execution within managed network environments.¶
To prevent malicious or corrupted management code from executing unauthorized operations, the Management Controller MUST execute a mandatory Ahead-of-Time Static Symbol Audit before bytecode encapsulation.¶
The audit pipeline enforces the following validation steps for self-contained core modules:¶
Import Table Extraction: The audit engine parses the WASM binary structure, filtering all tokens located within the "Import Section". This maps every external host function identifier requested by the bytecode.¶
Capability-Matrix Intersection: The extracted import symbols are cross-checked against the allowed-host-functions list declared in the Node Profile or execution policy.¶
Link-Time Rejection: The binary is scanned to ensure no raw hardware address references bypass the UBI layer. Any mismatch or inclusion of unauthorized tokens SHALL result in an immediate Link-Time rejection, aborting the transmission.¶
The execution of dynamically provisioned bytecode on remote physical devices mandates severe security practices. This framework achieves endogenous security via layers of defensive validation:¶
Linear Memory Boundary Isolation: Embedded runtimes MUST leverage virtual memory page capping to ensure that buffer overflows inside the sandboxed application cannot compromise host address spaces.¶
File System Namespacing: Runtimes MUST map the sandbox internal root '/' directory to an ephemeral host path using chroot primitives to avoid directory traversal vectors.¶
TBC per [I-D.opsarea-rfc5706bis].¶
This document requests IANA to create a registry for Universal Bytecode Interface (UBI) Functional Symbols under the Operations and Management Area.¶
TODO acknowledge.¶