Wassette: the sandbox that does not trust even the tool description
Wassette from Microsoft runs an agent’s MCP tools as WebAssembly components inside the Wasmtime sandbox: nothing touches the network, files, or keys unless you explicitly allow it. Our test on Windows 11 showed the same call being blocked in 0.074 seconds without permission and passing in 0.30 with permission for one host only.

What it does
An agent cannot do anything you have not given it as a tool. When you ask it to read a page, call an API, or inspect a file, it does not do it by itself; it asks a small helper program to do it for it. That helper program is called an MCP server — a “Model Context Protocol server.” Ten lines below you will see why the name does not matter; what matters is how it runs.
And it runs badly. A normal MCP server is an ordinary program: it can open a network connection, read any file it wants, and see the environment variables where you keep your keys. The only control you have before you run it is a text block — its description, written by whoever made it. If someone writes “harmless weather tool” and it actually does something else, you only learn that when you install it and then forget. The description is not a guard. It is an ad.
Wassette answers by changing the tool material itself, not by making the description better. It does not accept tools as ordinary programs (JavaScript, Python, whatever) running with your own privileges. It wants them compiled to WebAssembly and runs them inside the Wasmtime sandbox.
WebAssembly, in plain words, is code that is not written for your processor but for a “virtual” computer that the hosting program pretends to be. It was born in browsers, where it had to run fast without being able to touch the machine. Today it also runs outside the browser. A WebAssembly component is such a piece of code, self-contained, with no built-in way to talk to the operating system.
And this is the critical point. A normal program can in theory do everything, and your effort goes into stripping away rights. A WebAssembly component cannot do anything on its own: not open a file, not raise a connection, not read an environment variable. Every such action must go through the host program, which either grants it or does not. That is what we call a sandbox: a room where the occupant has no keys, no phone, and no window. Whatever reaches it, you bring through the door yourself.
And what does the title’s “deny by default” mean? It means that the absence of permission is already a refusal. You do not start from “everything is allowed and I remove what bothers me.” You start from “nothing is allowed,” and each capability is added by hand for a specific destination. Our experiment measured exactly that: permission for example.com meant that www.iana.org stayed closed. This is not “curse the bad servers.” It is “this cannot do anything I did not allow, no matter what its description says.”
Built on that material, Wassette is two things at once. First, a runtime: it loads components, keeps them in a directory, grants permissions, and runs them. Second, an MCP server itself: it speaks the protocol and exposes the components as tools to the agent. In our test it answered as serverInfo rmcp 3.5.1 with 15 tools.
The project belongs to Microsoft, and that matters because a runtime is only as trustworthy as the team behind it. The repository (https://github.com/microsoft/wassette) currently has 969 stars, 76 forks, and 58 open issues, under the MIT license — meaning you can use it commercially without asking anyone for permission. It was opened on 15 July 2025 and last changed on 20 October 2026, 19:28 UTC — that is, yesterday, at the time this text was written. Among the 22 people who have contributed code you see human names (asw101, Mossaka, yoshuawuyts, thomastaylor312), not only bots publishing releases. There have been 18 releases; the latest, v0.8.1, landed on 19 October 2026, 04:45 UTC. It is not on crates.io, winget has it at 0.4.0 — we will see below why that is a trap. And most importantly: it costs zero euros, zero keys, zero account.
What it does not do
It is not a security panacea. It does not replace code review or review of business logic. If you give a component rights to CPU or execution time, it can burn your machine with endless loops or heavy compute. The sandbox limits access to disk, network, and environment, but it does not safely limit resource use at the CPU or memory level for production.
It does not automatically compile whatever you find on GitHub into WebAssembly. You have to build the component, compile it to Wasm, and give it exact permissions. It does not manage keys or secrets unless you pass them in yourself. The trap is the illusion of safety: if you open broad permissions “for everything,” Wassette will not stop malicious or simply broken component logic. It is a tool for reducing exposure and for demos and tests, not a complete solution for production or governance.
Who it is for
If you give an agent the ability to call external tools, you have given it the sum of your own rights. Wassette is for you if that sentence makes you uncomfortable.
It is for the person who tests MCP servers from GitHub as if they were downloading apps. Every server added is an unknown program with access to the network and disk on its own. Wassette lets them say “this will only see example.com, nothing else” and mean it, without first reading source code in a language they do not know.
It is for anyone who asks the agent to pull data from outside — weather, prices, documentation — and does not want to grant the whole network for that privilege. It is for anyone who fears keys: Wassette does not ask for keys to work, and it sees no environment variable unless you open it by name.
It is also for people who build tools, not only for people who consume them. A WebAssembly component is not an MCP-only thing: you can run it elsewhere, share it, and put it in your own catalog. The project presents this as reuse, and that is a claim from the maker — the fact that a component is technically portable does not automatically mean the surrounding ecosystem is mature.
Who it is not for. It is not for production: the README itself says, plainly, that the repository is not ready for production and is in early development. It is not for anyone who wants one-click installation: the best Windows installer today is four versions behind. It is not for anyone who thinks the sandbox will save them from excess consumption: the sandbox limits access, not CPU. A badly written component can burn your machine without touching a single file, and it still stays within the limits you gave it.
Installation
The documentation recommends winget for Windows. Do not follow it. The winget package is at 0.4.0 while the current release is 0.8.1; four versions behind means you get old software in a tool whose value is precisely being current. The right path on Windows is the zip from the releases page, a file you unpack and run.
First step: download the file. The address we used, and checked today to return a file of 16,967,083 bytes (16.2 MB), is this:
curl -LO https://github.com/microsoft/wassette/releases/download/v0.8.1/wassette_0.8.1_windows_amd64.zip
Second step: unpack it into a folder of your own, for example C:\wassette. In our test we did this by hand (right click, Extract All) — we did not test another method, so I am not giving you a command I have not seen run.
Third step: check that the executable is what you think it is. From inside the folder:
wassette.exe --version
The answer was 0.8.1, built on 19 October 2026, 04:11 UTC, from a clean tag, with Rust 1.97.1. Inside the zip there is one executable, wassette.exe, 50,693,120 bytes — about 48.3 MB. It needed no installation, did not touch PATH, did not ask for Node, and did not ask for Python. You downloaded it, unpacked it, and it ran. That is rare these days, and it is worth saying.
If you want the executable on PATH
In our test we did not need it: we called wassette.exe with its full path from inside its folder. You will need this when you hand it to a client like Cursor or Codex, because they launch it by name. The simplest route is to copy wassette.exe into a folder that is already on PATH, such as %LOCALAPPDATA%\Microsoft\WindowsApps. We did not test that, so I am writing it as a recommendation, not as a measured step.
What does not work
cargo install wassette will not work. The component is not published on crates.io — the answer is explicit: “crate wassette does not exist.” The same applies to any guide that assumes installation through a Rust package.
winget install wassette will work, but it will give you 0.4.0. If you run it by mistake, remove it and take the zip.
A small bureaucratic detail that will cost you five minutes: the site address that points to the repository, microsoft.github.io/wassette/, returns 404 today. The documentation lives at microsoft.github.io/wassette/latest/. Start there.
Use with each LLM
Wassette speaks MCP, the language that all clients now speak. It has two ways to present itself. The first is via stdio, for local clients, and it starts with one word:
wassette run
The second is as a remote HTTP server, if you want it to serve many:
wassette serve
The rule that applies everywhere: no key, account, or subscription is needed to add it anywhere. The difference is only where the server is registered in each client. Before we continue, an honest note: we measured Wassette’s MCP path normally — 15 tools, tools/list in 0.1 seconds. We did not test the registration in each client on this machine. The steps below are the project documentation’s steps, and I say so so you know what I am guaranteeing and what I am not.
Claude Code
First install Claude Code, if you do not have it; it needs Node 18 or newer:
npm install -g @anthropic-ai/claude-code
Then add Wassette as a local server:
claude mcp add wassette -- wassette run
The project documentation page shows a variant with an extra -- before the name. We did not test either form, and the normal command syntax is the one you see above.
Check that it was registered:
claude mcp list
If something goes wrong and you want to remove it:
claude mcp remove wassette
From there on, do not write commands. Speak. Ask the agent to load a component, then ask it to use it, then ask it for permission. The phrase “give fetch-rs network permission only for example.com” is enough — the agent has a tool for that, grant-network-permission.
Codex CLI
Install Codex CLI:
npm install -g @openai/codex
Add the server:
codex mcp add wassette wassette run
Run codex and type /mcp to see that the server is up and the tools are visible. Unlike other clients, this registration is one command and not a file edit.
Codex CLI via config file
If you prefer to keep the configuration in a file, that file is %USERPROFILE%.codex\config.toml. Add this block:
[mcp_servers.wassette]
command = "wassette"
args = ["run"]
Cursor
Cursor has no registration command; it has a file. The global file is %USERPROFILE%.cursor\mcp.json, and the same file inside a project is .cursor/mcp.json. Open it and add:
{
"mcpServers": {
"wassette": {
"command": "wassette",
"args": ["run"]
}
}
}
Then restart the window or manage the server from settings, under Tools & MCP. Two things that break this setup: JSON does not allow a trailing comma (Cursor ignores it silently, with no message), and on Windows the command must point to an executable that exists on PATH. If wassette is not on PATH, use the full path with double backslashes:
{
"mcpServers": {
"wassette": {
"command": "C:\wassette\wassette.exe",
"args": ["run"]
}
}
}
Whatever you ask the agent in Cursor, it runs through the same executable we tested — under the same permission rules.
Where it wins, where it loses
It wins at the most important thing. It does not promise security; it enforces it. In our test, denial was measurable and immediate, and permission was specific, not broad. That difference — same command, different right, different result — is the whole point of the tool, and we measured it with a stopwatch.
It wins at transparency. The permission policy is a YAML file that a human can read. You do not need to know the component’s language to understand what it permits.
It wins on entry cost. One file, one executable, zero dependencies, zero keys. And Microsoft keeps it active: 18 releases, the latest three days ago, 22 contributors with human names.
It wins because it is not alone. Wassette is part of an ecosystem — Wasmtime, the component model, the WASI standard — that is not maintained by one person in one repository. That is the kind of foundation that lasts.
Now the traps, and there are several.
It is not ready for production, and it says so itself. The README begins with a warning about early development. If you put it somewhere serious, pin the version; never put latest on a critical path, because an upgrade you did not inspect can change the rules.
winget is four versions behind. Anyone who follows the documentation’s Windows recommendation gets 0.4.0 instead of 0.8.1. This is not just a number: what you read in the documentation about permissions, OCI, and behavior may not exist in the old binary.
There is a flag that opens its own network access. It is called –trust-bundled-policy and it does this: it accepts a permission policy that the component publisher has placed inside the OCI package. In other words, a component can arrive with a ready-made network permission, written by an unknown party. It is off by default, and where it is not off, the documentation says agent-loading paths remain closed. Stay there.
Permissions are per component, not per call. That sounds like a detail and it is not. Once you give a component permission for a host, every call it makes to that host from then on passes. There is no “just once.” The model is rights, not approvals.
The sandbox limits access, not consumption. A component can eat as much CPU as it wants, for as long as it wants, within the limits you gave it. Deny-access is not resource control.
wassette run loads all components in the directory. Clear, useful rule: do not mix experimental items with good ones. Keep a separate directory for each experiment, or the agent will see tools you forgot, with permissions you granted in another context.
And one gain worth saying in one sentence: it does not ask for keys and it sends nothing out beyond what you allow. In the world of agents, “it sends nothing” is a rare product.
Test
We ran everything on Windows 11, on the machine we work on, on 22 October 2026. Zip download: 16,967,083 bytes (16.2 MB), inside one executable, wassette.exe, 50,693,120 bytes. –version answered 0.8.1, built 19 October 2026, 04:11 UTC, with Rust 1.97.1.
Loading components from the OCI registry ghcr.io is the slowest moment in the process: time-server-js took 20.1 seconds, get-open-meteo-weather-js took 21.3 seconds, and fetch-rs also came down. That is network time, not compute time: you are waiting for the registry, not for your machine. The first time you measure it; after that it is local.
And the experiment that matters. We called the fetch tool for https://example.com with no permission at all. The answer came back in 0.074 seconds:
{"err": "ErrorCode::HttpRequestDenied"}
We granted permission only for example.com:
wassette permission grant network microsoft_fetch-rs example.com
Same call, and this time it passed: it fetched the page in 0.30 seconds. We immediately tried a host we had not allowed, https://www.iana.org/, and it answered HttpRequestDenied, in 0.069 seconds. We revoked the permission, and the original address closed again. Same command, different right, different result. This is not a poster; we saw it happen twice within one second.
The policy that results is the most convincing part of the tool, because a human who does not know the component language can read it. Six lines, complete:
version: "1.0"
description: "example.com only"
permissions:
network:
allow:
- host: "example.com"
Six lines. One host. Everything else closed — and you know it because you can see it, not because someone promised it.
Finally, the MCP path. The server introduced itself as rmcp 3.5.1 and declared 15 tools. tools/list answered in 0.1 seconds, and its schemas took 6,486 characters — about 1,622 tokens, our estimate, not a price-list measurement. Keep that in mind if you work with an agent with a narrow window: Wassette’s tools live permanently in the conversation frame, alongside everything else.
What it costs
Money: zero. It is open source under the MIT license, asks for no key, asks for no account, sets up no daemon, and sends nothing out beyond the calls you permit. The only thing you pay for is whatever the agent does on top of it.
Disk: the zip is 16.2 MB and inside it hides one executable of 48.3 MB. In our test, three components from ghcr.io occupied another 97 MB — the .cwasm files are precompiled WebAssembly, which is why they are large, and you win that back in startup time. It is disk, not memory, and you can delete it whenever you want.
Time: loading one component took 20.1 and 21.3 seconds — network time, done once and then local. tools/list answered in 0.1 seconds, and the refusal answer came in 0.074 seconds: denial does not cost time.
The frame, the number worth remembering: as an MCP server, Wassette exposes 15 tools and their schemas take 6,486 characters, or about 1,622 tokens in each session — characters divided by four, our estimate and not a price-list measurement. Beside it, the GitHub MCP server is said to be around 55,000 tokens: a maker’s claim, not ours. The path without MCP has zero tax. If you work with a narrow window, that difference decides more than price.
The verdict on cost: money zero, disk reasonable, time once, and the only recurring cost is the frame — which you choose yourself. A security tool that costs like a tool, not like a cloud, in a space where security is usually priced like a luxury.
Verdict
Wassette is the first agent security tool we tested and saw enforcing its claim instead of advertising it. What makes it useful is not the technology — WebAssembly is not new — but the order of the logic: it does not ask whether the server is bad, it says what it is allowed to do. It does this even when the tool description lies.
What we would do with it tomorrow. I would use it in my work for every third tool I test, because the alternative is giving unknown code the whole network. I would not put it in production, and I would not put latest anywhere serious, because the project itself says it is early.
Is it worth it? If you give agents tools you did not write, it is worth the time. Twenty minutes at most, and half of that is downloading components. It does not solve the trust problem; it reduces it to something you can look in the eye: six lines of YAML.
Score: 8/10.
See also
Related, from the same category:
- Trivy: one file that tells you in seconds what holes your project has
- zizmor: workflow security is checked before the code runs
- Kingfisher: the scanner that catches the keys you thought you had deleted
Sources:
https://github.com/microsoft/wassette
Εγκατάσταση
3 ΒΗΜΑΤΑ- curl -LO https://github.com/microsoft/wassette/releases/download/v0.8.1/wassette_0.8.1_windows_amd64.zip
- npm install -g @anthropic-ai/claude-code
- npm install -g @openai/codex