Plugins

Universal WebAssembly Tools for AI Agents

Build custom capabilities in any language. Deploy as standard WebAssembly components. Zero vendor lock-in, automatic tool discovery.

WebAssembly Component Model

Advanced type systems and automatic tool discovery

The Component Model provides rich type systems, capability-based security, and seamless cross-language interoperability. Define your plugin's API once using WIT (WebAssembly Interface Types), and the platform automatically discovers exported functions, generates JSON schemas, and exposes them as MCP tools—no manual configuration needed.

WIT acts as your plugin's interface definition language with strong typing across language boundaries. Write comments in your WIT file, and they automatically become tool descriptions. Export a function, and it immediately becomes available to all agents. Zero configuration, complete type safety.

Each plugin runs in a secure Wasmtime sandbox with complete isolation. Battle-tested by companies like Shopify and Fastly, Wasmtime delivers microsecond cold starts—1000x faster than containers—with near-native performance through ahead-of-time compilation. Resource limits ensure platform stability, while capability-based security provides fine-grained permission control.

Architecture

Automatic Tool Discovery

No configuration files, no manual registration—just export functions

Define Your API

package noorle:example;

world example-plugin {
  /// Process input data
  export process: func(
    input: string
  ) -> result<string, string>;
}

Automatically Becomes MCP Tool

{
  "name": "process",
  "description": "Process input data",
  "inputSchema": {
    "type": "object",
    "properties": {
      "input": { "type": "string" }
    }
  }
}

How Auto-Discovery Works

Platform Actions

1. Introspects WIT interface definition
2. Discovers all exported functions
3. Generates JSON schemas for parameters
4. Exposes functions as MCP tools

Developer Experience

✓ Zero configuration needed
✓ WIT comments become tool descriptions
✓ Type-safe across language boundaries
✓ Available immediately after deployment

Language Freedom

Build with What You Know

Templates and examples available for all languages below

Python

TypeScript

JavaScript

Rust

Full template support with examples for all 5 languages

Any language that compiles to WebAssembly works: C++, C#, Zig, AssemblyScript, and more

Developer Experience

Build, Test, Deploy in Minutes

Noorle CLI

Streamlined plugin development from initialization to production deployment. Templates include build configurations, type definitions, and example implementations for all supported languages.

Development Flow

noorle plugin init Create from template
noorle plugin prepare Install dependencies
noorle plugin build Compile to WebAssembly
noorle plugin deploy Deploy to platform

Installation: curl -L cli.noorle.dev | sh

$ noorle plugin init weather --template python
  ✓ Created weather/
  ✓ Generated project files
  ✓ WIT interface ready

$ cd weather && noorle plugin prepare
  ✓ Installed Python toolchain
  ✓ Installed componentize-py
  ✓ Dependencies ready

$ noorle plugin build
  ✓ Compiled to WebAssembly
  ✓ Created plugin.wasm (847KB)

$ noorle plugin deploy
  → Authenticating...
  ✓ Plugin deployed as v1
  ✓ Available to all agents

No Vendor Lock-in

True portability across the entire ecosystem

There are no "Noorle-specific" WebAssembly components. Your plugins compile to standard WASI components that work in any compatible runtime—Wasmtime, WAMR, or any future WASI implementation. Components built for Noorle work elsewhere, and components from other platforms work in Noorle.

Write your plugin once in Python, Rust, TypeScript, Go, or JavaScript using standard toolchains. The resulting WebAssembly component is yours to deploy anywhere. Use it in local development with Wasmtime, embed it in edge computing platforms, or run it on other WebAssembly services. Your investment in plugin development isn't tied to our platform.

Leverage the entire WebAssembly ecosystem: import existing components, share your components with others, and benefit from a growing library of portable, composable modules. The Component Model ensures true interoperability across languages, platforms, and vendors.

Deploy Anywhere

• Noorle Platform (production hosting)
• Wasmtime (local development & testing)
• WAMR (embedded & IoT devices)
• Edge platforms (Fastly, Cloudflare)
• Any future WASI-compatible runtime

Ecosystem Freedom

• Standard toolchains (no proprietary SDKs)
• Open Component Model specification
• Compatible with existing Wasm components
• Export your work to other platforms
• Future-proof against vendor changes

Use Cases

What You Can Build

Real-world plugin categories developers create

API Integrations

OAuth flow handlers, request signing, rate limit management, response transformation, error normalization, custom authentication.

Data Transformers

CSV to JSON converters, XML parsers, protocol buffers, custom serialization formats, data validation, schema transformations.

Parsers & Generators

Markdown to HTML, syntax highlighters, template engines, code formatters, schema validators, DSL parsers.

Cryptographic Tools

Hash functions, HMAC generators, JWT creation and validation, encryption/decryption, digital signatures, key derivation.

Mathematical Functions

Statistical analysis, linear algebra, optimization algorithms, scientific computing, financial calculations, unit conversions.

Business Logic

Workflow orchestration, rule engines, decision trees, state machines, validation pipelines, custom process automation.

Specifications

Technical Details

Platform capabilities and constraints

Component Requirements

WebAssembly components using Component Model. WIT interface definition required. Standard WASI imports supported. Language toolchains handle compilation.

Security & Isolation

Complete sandboxing per execution. Capability-based permissions via noorle.yaml. No network/filesystem access unless explicitly granted. Resource limits enforced.

Performance

Microsecond cold starts via Wasmtime. Near-native execution speed through AOT compilation. Efficient resource usage. Instant availability after deployment.

Platform Limits

Memory: 128MB default, 512MB max (configurable). CPU: Max 100ms per request. Timeout: 30s default, 120s max (configurable). Module size: 10MB max.

Configuration

Optional Permissions & Metadata

Plugins work without configuration. Add noorle.yaml only when you need permissions.

schema_version: "1.0"

permissions:
  network:
    allow:
      - host: "api.example.com"
  environment:
    allow:
      - API_KEY
      - DEBUG_MODE

Network Access

Specify allowed hosts for HTTP requests

Environment Variables

List accessible environment variables

Resource Limits

Configure memory and timeout within platform limits

FAQs

Frequently Asked Questions

Everything you need to know about Noorle plugins

What makes Noorle plugins different?

Noorle plugins are standard WebAssembly components with no vendor lock-in. They use the Component Model for auto-discovery—functions you export automatically become MCP tools without configuration. Build once, run anywhere.

What languages are supported?

Python, TypeScript, JavaScript, Rust, and Go have full support with templates. Any language that compiles to WebAssembly can be used with custom build scripts.

How does auto-discovery work?

When you deploy a plugin, Noorle introspects the WIT interface definition, discovers all exported functions, generates JSON schemas, and exposes them as MCP tools. Comments in WIT files become tool descriptions. Zero configuration needed.

Are plugins locked to Noorle?

No! Plugins compile to standard WASI components that work in any compatible runtime (Wasmtime, WAMR, etc.). There are no "Noorle-specific" components—just open standards.

How secure are plugins?

Plugins run in complete WebAssembly sandboxes with no system access. Capability-based security through noorle.yaml controls network, filesystem, and environment access. Each execution is fully isolated.

How fast are plugins?

Wasmtime provides microsecond cold starts—1000x faster than containers—with near-native execution speed through AOT compilation. Plugins are available instantly after deployment.

What is WIT?

WIT (WebAssembly Interface Types) is the IDL for WebAssembly components. It defines your plugin API with strong typing across languages. Functions, types, and documentation are all declared in WIT.

Can I use external libraries?

Yes, as long as they compile to WebAssembly. Most pure computation libraries work perfectly. Network or filesystem access requires permissions in noorle.yaml.

How does versioning work?

The platform automatically versions your plugins on each deployment with semantic versioning support. Zero-downtime deployments and instant rollback capabilities.

What is WebAssembly?

WebAssembly (Wasm) is a binary instruction format that allows you to run code written in languages like Rust, Python, Go, and TypeScript at near-native speed in a sandboxed environment.

What is the Component Model?

The WebAssembly Component Model enables seamless, cross-language interoperability. You can build a plugin in Python and use it with a component written in Rust, all without writing any glue code.

What is WASI?

WASI (WebAssembly System Interface) provides standard system interfaces for WebAssembly, including file system access, network operations, environment variables, random number generation, and clocks—all with capability-based security.

Ready to Build Universal Tools?

Create WebAssembly plugins in your language of choice. Deploy in minutes, run anywhere.

Start Building Read Documentation